Upload folder using huggingface_hub

custom_nodes/openrouter_node/.github/workflows/publish.yml

@@ -0,0 +1,28 @@
+name: Publish to Comfy registry
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+      - master
+    paths:
+      - "pyproject.toml"
+
+permissions:
+  issues: write
+
+jobs:
+  publish-node:
+    name: Publish Custom Node to registry
+    runs-on: ubuntu-latest
+    if: ${{ github.repository_owner == 'gabe-init' }}
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v4
+        with:
+          submodules: true
+      - name: Publish Custom Node
+        uses: Comfy-Org/publish-node-action@v1
+        with:
+          ## Add your own personal access token to your Github Repository secrets and reference it here.
+          personal_access_token: ${{ secrets.REGISTRY_ACCESS_TOKEN }}

custom_nodes/openrouter_node/.gitignore

@@ -0,0 +1,47 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Environment
+.env
+.venv
+env/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+*.Zone.Identifier
+
+# Secrets
+api_keys.json
+secrets.json
+*.key
+openrouter_api_key.json
+chats/

custom_nodes/openrouter_node/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 gabe-init
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

custom_nodes/openrouter_node/README.md

@@ -0,0 +1,259 @@
+# ComfyUI OpenRouter Node
+
+A custom node for ComfyUI that allows you to interact with OpenRouter's API, providing access to a wide range of models.  
+
+## Updates
+
+### 5/18/2026
+
+Reasoning effort setting added. Make sure the model supports reasoning when using
+
+### 5/9/2026 - Secure API Key Loading
+
+You can now load your API key from a JSON config or env var instead of typing it into the node, which avoids leaking it in workflow metadata when sharing images.
+
+- **JSON config:** put `{"api_key": "your_key_here"}` in `openrouter_api_key.json` in the node directory, leave the field blank
+- **Env var:** set `LLM_KEY`, leave the field blank
+- **UI field:** still works if you don't share workflows
+
+
+### 4/5/2026 - Seed, Resolution, Aspect Ratio, Temperature Fix
+- Added **seed** input
+- Added **image_resolution** dropdown (1K, 2K, 4K)
+- Added **aspect_ratio** dropdown with all supported ratios, including Nano Banana 2 only extended ratios (1:4, 4:1, 1:8, 8:1)
+- Fixed temperature slider
+- 0.5K resolution (Nano Banana 2 only) not added - currently broken on OpenRouter's end, see [this thread](https://discord.com/channels/1091220969173028894/1484099048100073484/1484099048100073484) in the OpenRouter Discord
+
+![Nano Banana Example](./nano_banana_example.jpeg)
+
+![OpenRouter Node Example](https://github.com/gabe-init/ComfyUI-Openrouter_node/blob/main/openrouter_node_example.png?raw=true)
+
+Multiple image inputs are supported. Make sure the model you are using supports multiple images to be sent at once. Thanks **@wTechArtist** for the idea!
+![Multiple Images Example](https://github.com/user-attachments/assets/09f2478c-c4f8-46f0-b79e-e4766f020119)
+
+### 9/5/2025 - Added image support for nano-banana and future image models
+
+### 6/12/2025 - Chat Mode
+Added a new Chat Mode feature that lets you store context to enable conversations with LLMs. When you enable chat mode, the node remembers your conversation history and maintains context between messages. Your chats are automatically saved in timestamped folders, so you can pick up where you left off if you come back within an hour. After that, it'll start a fresh conversation. Each chat session is stored as a JSON file with a friendly name based on your first message. Just toggle "chat_mode" 
+
+## Features
+
+- Access to all models available on OpenRouter
+- Support for multiple image inputs (up to 10 images) 
+- **NEW: Image generation support** - Generate images with models like google/gemini-2.5-flash-image-preview (Nano-Banana)
+- Dynamic image input visibility - additional inputs appear as you connect images
+- PDF support with multiple OCR engine options
+- Web search capability with `:online` modifier
+- Cheapest provider routing with `:floor` modifier
+- Fastest provider routing with `:nitro` modifier
+- Detailed statistics on token usage and generation speed
+- Real-time OpenRouter account balance display
+- **Chat Mode** - Maintain conversation context across multiple messages with automatic session management
+
+## Installation
+
+1. Clone this repository into your ComfyUI custom_nodes folder:
+```bash
+cd ComfyUI/custom_nodes
+git clone https://github.com/gabe-init/ComfyUI-Openrouter_node
+```
+
+2. Install the required dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+3. Restart ComfyUI
+
+## Usage
+
+The OpenRouter node provides a simple interface to interact with various LLMs through the OpenRouter API.
+
+### API Key Security
+
+> [!WARNING]
+> Entering your API key directly into the node's input field in ComfyUI will embed it in the **workflow metadata** of every image you save. This is a security risk if you share your images.
+
+To keep your API key secure, use one of the following methods:
+
+1.  **JSON Config File (Recommended)**:
+    - Create a file named `openrouter_api_key.json` in the node directory.
+    - Add your key like this: `{"api_key": "your_key_here"}`.
+    - Leave the **api_key** field blank in the ComfyUI interface.
+
+2.  **Environment Variable**:
+    - Set an environment variable named `LLM_KEY` on your system.
+    - The node will automatically pick it up if the UI field is empty.
+
+> [!NOTE]
+> If you've ever typed your key into the **api_key** field, clear it before saving the workflow — the value is stored in the workflow JSON. On Linux/macOS, restrict the JSON config with `chmod 600 openrouter_api_key.json` so only your user can read it.
+
+### Inputs
+
+#### Required Inputs:
+
+- **api_key**: Your OpenRouter API key. Can be left blank if provided via `openrouter_api_key.json` or `LLM_KEY` environment variable.
+- **system_prompt**: The system prompt that sets the behavior of the LLM.
+- **user_message_box**: The user message to send to the LLM.
+- **model**: The model to use for generation. The node automatically fetches the list of available models from OpenRouter.
+- **web_search**: Enable web search capability by appending `:online` to the model ID. This costs $4 per 1000 queries and automatically uses your openrouter balance.
+- **cheapest**: Route to the cheapest provider by appending `:floor` to the model ID (enabled by default).
+- **fastest**: Route to the fastest provider by appending `:nitro` to the model ID (disabled by default).
+- **temperature**: Controls the randomness of the model's output (0.0 to 2.0).
+- **reasoning_effort**: Controls OpenRouter's unified reasoning parameter. `auto` sends no override and lets OpenRouter/model defaults apply. `none` explicitly disables reasoning. `minimal`, `low`, `medium`, `high`, and `xhigh` request increasing reasoning effort where the selected model supports it.
+- **chat_mode**: Enable conversation mode to maintain context across messages (disabled by default).
+- **request_timeout**: Maximum time, in seconds, to wait for the main OpenRouter completion request before returning an error (default: 120).
+
+> [!NOTE]
+> OpenRouter normalizes reasoning across providers, but behavior still depends on the selected model. Some providers map effort levels to token budgets, Gemini 3 maps effort to Google's thinking levels, `xhigh` may be mapped down when unsupported, and some reasoning models do not return visible reasoning tokens.
+
+#### Optional Inputs:
+
+- **image_1** through **image_10**: Multiple image inputs for multimodal models. The first image input (image_1) is always visible. Additional image inputs automatically appear as you connect images (up to 10 total).
+- **pdf_data**: PDF document input for models that support document understanding.
+- **pdf_engine**: Choose between "auto", "mistral-ocr", or "pdf-text" for PDF processing.
+- **user_message_input**: Alternative input for the user message, useful for connecting to other nodes.
+
+### Outputs:
+
+- **Output**: The text response from the LLM.
+- **image**: An image tensor if the response contains a generated image, otherwise returns an empty tensor.
+- **Stats**: A string detailing tokens per second, input tokens, output tokens, temperature, and the model used.
+- **Credits**: A string showing your remaining OpenRouter account balance (e.g., "Remaining: $9.792").
+
+Note: To display the output text in ComfyUI, you can use the ShowText nodes from [ComfyUI-Custom-Scripts](https://github.com/pythongosssss/ComfyUI-Custom-Scripts), but any text display node will work.
+
+## Examples
+
+### Basic Text Generation
+
+1. Add the OpenRouter node to your workflow
+2. Provide your API key (see [API Key Security](#api-key-security))
+3. Set a system prompt (e.g., "You are a helpful assistant.")
+4. Enter a user message (e.g., "Explain quantum computing in simple terms.")
+5. Select a model (e.g., "openai/gpt-4")
+6. Run the workflow
+
+### Image Understanding
+
+1. Add the OpenRouter node to your workflow
+2. Connect an image output from another node to the "image_1" input
+3. Provide your API key (see [API Key Security](#api-key-security))
+4. Set a system prompt (e.g., "You are a helpful assistant.")
+5. Enter a user message (e.g., "Describe this image in detail.")
+6. Select a multimodal model (e.g., "openai/gpt-4-vision" or "anthropic/claude-3-opus-20240229")
+7. Run the workflow
+
+### Multiple Image Analysis
+
+1. Connect your first image to "image_1"
+2. As soon as you connect it, "image_2" will automatically appear
+3. Connect additional images as needed (up to 6 total)
+4. Unused image inputs will automatically hide when disconnected
+5. Enter a prompt that references multiple images (e.g., "Compare these images and describe the differences.")
+6. Select a multimodal model that supports multiple images
+7. Run the workflow
+
+**Note**: The user is responsible for checking if their selected model supports multiple images. Most modern multimodal models (4o, Gemini Flash, etc.) support multiple images in a single request.
+
+### Image Generation
+
+1. Add the OpenRouter node to your workflow
+2. Provide your API key (see [API Key Security](#api-key-security))
+3. Set a system prompt (e.g., "You are a helpful assistant.")
+4. Enter a user message with generation keywords (e.g., "Generate a beautiful sunset over mountains", "Create an image of a futuristic city", "Draw a cat wearing a hat")
+5. Select an image-capable model (e.g., "google/gemini-2.5-flash-image-preview" - also known as Nano-Banana)
+6. Run the workflow
+7. The generated image will appear in the "image" output, which you can connect to preview nodes or other image processing nodes
+
+**Note**: The node automatically detects image generation requests based on keywords like "generate", "create", "draw", "make", "produce", "design", "render", "image of", "picture of", "photo of". For image generation, use models that support image output modalities.
+
+### Chat Mode
+
+The Chat Mode feature allows you to maintain conversation context across multiple messages, enabling more natural and coherent conversations with the LLM.
+
+#### How Chat Mode Works:
+
+1. **Enable Chat Mode**: Toggle the "chat_mode" option to True
+2. **Automatic Session Management**: 
+   - Sessions are automatically created when you start a conversation
+   - If you send another message within 1 hour, it continues the same session
+   - After 1 hour of inactivity, a new session is created
+3. **Session Storage**:
+   - Conversations are stored in a `chats` folder within the node directory
+   - Each session is saved with a timestamp and the first 5 words of your initial message
+   - Format: `session_YYYYMMDD_HHMMSS_first_five_words`
+4. **Context Preservation**: The entire conversation history is sent with each request, allowing the model to maintain context
+
+#### Chat Mode Example:
+
+1. Enable chat_mode in the node
+2. First message: "Hello, my name is Alice"
+3. Response: "Hello Alice! Nice to meet you. How can I help you today?"
+4. Second message: "What's my name?"
+5. Response: "Your name is Alice, as you mentioned earlier."
+
+The conversation history is automatically managed and persisted between runs.
+
+#### Managing Chat Sessions:
+
+A utility script `manage_chats.py` is included to help you manage your chat sessions:
+
+```bash
+# List all chat sessions
+python manage_chats.py list
+
+# View a specific session
+python manage_chats.py view session_20241206_143022_hello_how_are_you_today
+
+# Export a session to different formats (json, txt, md)
+python manage_chats.py export session_20241206_143022_hello_how_are_you_today -f md -o my_chat.md
+
+# Clean up sessions older than 30 days
+python manage_chats.py clean -d 30
+```
+
+### Routing Options
+
+- For cost-effective responses, enable the "cheapest" option (on by default)
+- For faster responses, disable "cheapest" and enable "fastest"
+- For web search capability, enable "web_search"
+
+## Troubleshooting
+
+- **Model list not loading**: Check your internet connection and OpenRouter API key.
+- **Error in response**: Check the error message in the output. It might be due to an invalid API key, model unavailability, or other API issues.
+- **Slow responses**: Try using the `:nitro` modifier by enabling the "fastest" option.
+- **Token counting issues**: The node uses tiktoken for accurate token counting, but falls back to an estimation method if there's an issue.
+
+## License
+
+MIT License
+
+Copyright (c) 2024 
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+## Credits
+
+- [OpenRouter](https://openrouter.ai/) 
+- [ComfyUI](https://github.com/comfyanonymous/ComfyUI) 
+
+
+

custom_nodes/openrouter_node/__init__.py

@@ -0,0 +1,5 @@
+from .node import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
+
+WEB_DIRECTORY = "./web"
+__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS", "WEB_DIRECTORY"]
+

custom_nodes/openrouter_node/chat_manager.py

@@ -0,0 +1,309 @@
+import os
+import json
+import datetime
+import re
+from pathlib import Path
+from typing import List, Dict, Optional, Tuple
+import time
+
+class ChatSessionManager:
+    """
+    Manages chat sessions for the OpenRouter node.
+    Handles creating, loading, and updating chat conversations with automatic session management.
+    """
+    
+    def __init__(self, base_path: str = None):
+        """
+        Initialize the chat session manager.
+        
+        Args:
+            base_path: Base directory for storing chats. Defaults to node's directory + /chats
+        """
+        if base_path is None:
+            base_path = os.path.join(os.path.dirname(__file__), "chats")
+        
+        self.base_path = Path(base_path)
+        self.base_path.mkdir(exist_ok=True)
+        self.current_session_path = None
+        self.session_timeout_hours = 1  # Sessions expire after 1 hour of inactivity
+    
+    def _sanitize_filename(self, text: str, max_length: int = 50) -> str:
+        """
+        Sanitize text for use in filenames.
+        
+        Args:
+            text: Text to sanitize
+            max_length: Maximum length of the sanitized text
+            
+        Returns:
+            Sanitized text safe for filenames
+        """
+        # Get first 5 words or max_length characters, whichever is shorter
+        words = text.split()[:5]
+        text = " ".join(words)
+        
+        # Remove special characters
+        text = re.sub(r'[^\w\s-]', '', text)
+        text = re.sub(r'[-\s]+', '_', text)
+        
+        # Truncate to max length
+        if len(text) > max_length:
+            text = text[:max_length].rstrip('_')
+        
+        return text.lower()
+    
+    def _get_timestamp(self) -> str:
+        """Get current timestamp in format YYYYMMDD_HHMMSS"""
+        return datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    
+    def _get_iso_timestamp(self) -> str:
+        """Get current timestamp in ISO format"""
+        return datetime.datetime.now().isoformat()
+    
+    def _find_active_session(self) -> Optional[Path]:
+        """
+        Find an active session within the timeout period.
+        
+        Returns:
+            Path to active session directory or None
+        """
+        if not self.base_path.exists():
+            return None
+        
+        current_time = time.time()
+        
+        # Get all session directories
+        sessions = [d for d in self.base_path.iterdir() if d.is_dir()]
+        
+        # Sort by modification time (most recent first)
+        sessions.sort(key=lambda x: x.stat().st_mtime, reverse=True)
+        
+        for session_dir in sessions:
+            conversation_file = session_dir / "conversation.json"
+            if conversation_file.exists():
+                # Check if session is within timeout period
+                last_modified = conversation_file.stat().st_mtime
+                hours_elapsed = (current_time - last_modified) / 3600
+                
+                if hours_elapsed <= self.session_timeout_hours:
+                    return session_dir
+        
+        return None
+    
+    def _create_new_session(self, first_message: str) -> Path:
+        """
+        Create a new chat session directory.
+        
+        Args:
+            first_message: The first user message to use in the session name
+            
+        Returns:
+            Path to the new session directory
+        """
+        timestamp = self._get_timestamp()
+        sanitized_message = self._sanitize_filename(first_message)
+        
+        # Create session directory name
+        session_name = f"session_{timestamp}_{sanitized_message}"
+        session_path = self.base_path / session_name
+        
+        # Handle potential naming conflicts
+        counter = 1
+        while session_path.exists():
+            session_path = self.base_path / f"{session_name}_{counter}"
+            counter += 1
+        
+        session_path.mkdir(exist_ok=True)
+        return session_path
+    
+    def get_or_create_session(self, user_message: str, system_prompt: str) -> Tuple[Path, List[Dict]]:
+        """
+        Get an active session or create a new one.
+        
+        Args:
+            user_message: The current user message
+            system_prompt: The system prompt to use
+            
+        Returns:
+            Tuple of (session_path, message_history)
+        """
+        # Try to find an active session
+        active_session = self._find_active_session()
+        
+        if active_session:
+            self.current_session_path = active_session
+            messages = self.load_conversation(active_session)
+            return active_session, messages
+        else:
+            # Create new session
+            new_session = self._create_new_session(user_message)
+            self.current_session_path = new_session
+            
+            # Initialize with system prompt
+            messages = [{"role": "system", "content": system_prompt}]
+            
+            # Create initial conversation file
+            conversation_data = {
+                "session_id": new_session.name,
+                "created_at": self._get_iso_timestamp(),
+                "last_updated": self._get_iso_timestamp(),
+                "messages": messages
+            }
+            
+            conversation_file = new_session / "conversation.json"
+            with open(conversation_file, 'w', encoding='utf-8') as f:
+                json.dump(conversation_data, f, indent=2, ensure_ascii=False)
+            
+            return new_session, messages
+    
+    def load_conversation(self, session_path: Path) -> List[Dict]:
+        """
+        Load conversation history from a session.
+        
+        Args:
+            session_path: Path to the session directory
+            
+        Returns:
+            List of messages in the conversation
+        """
+        conversation_file = session_path / "conversation.json"
+        
+        if not conversation_file.exists():
+            return []
+        
+        try:
+            with open(conversation_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                return data.get("messages", [])
+        except (json.JSONDecodeError, IOError) as e:
+            print(f"Error loading conversation from {conversation_file}: {e}")
+            return []
+    
+    def save_conversation(self, session_path: Path, messages: List[Dict]):
+        """
+        Save conversation history to a session.
+        
+        Args:
+            session_path: Path to the session directory
+            messages: List of messages to save
+        """
+        conversation_file = session_path / "conversation.json"
+        
+        # Load existing data to preserve metadata
+        existing_data = {}
+        if conversation_file.exists():
+            try:
+                with open(conversation_file, 'r', encoding='utf-8') as f:
+                    existing_data = json.load(f)
+            except (json.JSONDecodeError, IOError):
+                pass
+        
+        # Update conversation data
+        conversation_data = {
+            "session_id": existing_data.get("session_id", session_path.name),
+            "created_at": existing_data.get("created_at", self._get_iso_timestamp()),
+            "last_updated": self._get_iso_timestamp(),
+            "messages": messages
+        }
+        
+        # Save to file
+        try:
+            with open(conversation_file, 'w', encoding='utf-8') as f:
+                json.dump(conversation_data, f, indent=2, ensure_ascii=False)
+        except IOError as e:
+            print(f"Error saving conversation to {conversation_file}: {e}")
+    
+    def append_message(self, role: str, content: str, session_path: Optional[Path] = None):
+        """
+        Append a message to the current or specified session.
+        
+        Args:
+            role: Message role ('user', 'assistant', or 'system')
+            content: Message content
+            session_path: Optional specific session path, uses current if not provided
+        """
+        if session_path is None:
+            session_path = self.current_session_path
+        
+        if session_path is None:
+            raise ValueError("No active session to append message to")
+        
+        # Load existing messages
+        messages = self.load_conversation(session_path)
+        
+        # Append new message
+        messages.append({
+            "role": role,
+            "content": content,
+            "timestamp": self._get_iso_timestamp()
+        })
+        
+        # Save updated conversation
+        self.save_conversation(session_path, messages)
+    
+    def get_recent_sessions(self, limit: int = 10) -> List[Dict]:
+        """
+        Get a list of recent chat sessions.
+        
+        Args:
+            limit: Maximum number of sessions to return
+            
+        Returns:
+            List of session metadata dictionaries
+        """
+        if not self.base_path.exists():
+            return []
+        
+        sessions = []
+        session_dirs = [d for d in self.base_path.iterdir() if d.is_dir()]
+        
+        # Sort by modification time (most recent first)
+        session_dirs.sort(key=lambda x: x.stat().st_mtime, reverse=True)
+        
+        for session_dir in session_dirs[:limit]:
+            conversation_file = session_dir / "conversation.json"
+            if conversation_file.exists():
+                try:
+                    with open(conversation_file, 'r', encoding='utf-8') as f:
+                        data = json.load(f)
+                        sessions.append({
+                            "session_id": data.get("session_id", session_dir.name),
+                            "path": str(session_dir),
+                            "created_at": data.get("created_at"),
+                            "last_updated": data.get("last_updated"),
+                            "message_count": len(data.get("messages", [])),
+                            "first_user_message": next(
+                                (msg["content"] for msg in data.get("messages", []) 
+                                 if msg["role"] == "user"), 
+                                "No user message"
+                            )[:100]  # First 100 chars of first user message
+                        })
+                except (json.JSONDecodeError, IOError):
+                    continue
+        
+        return sessions
+    
+    def clear_old_sessions(self, days: int = 30):
+        """
+        Clear sessions older than specified days.
+        
+        Args:
+            days: Number of days to keep sessions
+        """
+        if not self.base_path.exists():
+            return
+        
+        current_time = time.time()
+        cutoff_time = current_time - (days * 24 * 3600)
+        
+        for session_dir in self.base_path.iterdir():
+            if session_dir.is_dir():
+                # Check modification time
+                if session_dir.stat().st_mtime < cutoff_time:
+                    # Remove old session
+                    try:
+                        import shutil
+                        shutil.rmtree(session_dir)
+                        print(f"Removed old session: {session_dir.name}")
+                    except Exception as e:
+                        print(f"Error removing session {session_dir.name}: {e}")

custom_nodes/openrouter_node/examples/chat_mode_example.json

@@ -0,0 +1,130 @@
+{
+  "last_node_id": 3,
+  "last_link_id": 2,
+  "nodes": [
+    {
+      "id": 1,
+      "type": "OpenRouterNode",
+      "pos": [400, 200],
+      "size": [400, 400],
+      "flags": {},
+      "order": 0,
+      "mode": 0,
+      "inputs": [],
+      "outputs": [
+        {
+          "name": "Output",
+          "type": "STRING",
+          "links": [1],
+          "shape": 3,
+          "slot_index": 0
+        },
+        {
+          "name": "Stats",
+          "type": "STRING",
+          "links": [2],
+          "shape": 3,
+          "slot_index": 1
+        },
+        {
+          "name": "Credits",
+          "type": "STRING",
+          "links": null,
+          "shape": 3
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "OpenRouterNode"
+      },
+      "widgets_values": [
+        "",
+        "You are a helpful AI assistant. Please provide thoughtful and accurate responses.",
+        "Hello! Let's have a conversation.",
+        "openai/gpt-3.5-turbo",
+        false,
+        true,
+        false,
+        1,
+        "auto",
+        true
+      ]
+    },
+    {
+      "id": 2,
+      "type": "ShowText|pysssss",
+      "pos": [850, 200],
+      "size": [400, 200],
+      "flags": {},
+      "order": 1,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 1
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": null,
+          "shape": 6
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ShowText|pysssss"
+      },
+      "widgets_values": ["", ""]
+    },
+    {
+      "id": 3,
+      "type": "ShowText|pysssss",
+      "pos": [850, 450],
+      "size": [400, 100],
+      "flags": {},
+      "order": 2,
+      "mode": 0,
+      "inputs": [
+        {
+          "name": "text",
+          "type": "STRING",
+          "link": 2
+        }
+      ],
+      "outputs": [
+        {
+          "name": "STRING",
+          "type": "STRING",
+          "links": null,
+          "shape": 6
+        }
+      ],
+      "properties": {
+        "Node name for S&R": "ShowText|pysssss"
+      },
+      "widgets_values": ["", ""]
+    }
+  ],
+  "links": [
+    [1, 1, 0, 2, 0, "STRING"],
+    [2, 1, 1, 3, 0, "STRING"]
+  ],
+  "groups": [
+    {
+      "title": "Chat Mode Example",
+      "bounding": [380, 120, 900, 500],
+      "color": "#3f789e",
+      "font_size": 24,
+      "locked": false
+    }
+  ],
+  "config": {},
+  "extra": {
+    "workflow": {
+      "title": "OpenRouter Chat Mode Example",
+      "description": "This workflow demonstrates the chat mode feature. When chat mode is enabled, conversations are automatically saved and context is maintained across messages. Sessions expire after 1 hour of inactivity."
+    }
+  },
+  "version": 0.4
+}

custom_nodes/openrouter_node/manage_chats.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""
+Chat Session Management Utility for OpenRouter Node
+
+This script provides utilities to manage chat sessions:
+- List all chat sessions
+- View a specific session
+- Export sessions to different formats
+- Clean up old sessions
+"""
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+from chat_manager import ChatSessionManager
+
+def list_sessions(manager: ChatSessionManager, limit: int = None):
+    """List all chat sessions"""
+    sessions = manager.get_recent_sessions(limit or 1000)
+    
+    if not sessions:
+        print("No chat sessions found.")
+        return
+    
+    print(f"\nFound {len(sessions)} chat session(s):\n")
+    print(f"{'#':<4} {'Session ID':<50} {'Created':<20} {'Messages':<10} {'First Message':<50}")
+    print("-" * 140)
+    
+    for i, session in enumerate(sessions, 1):
+        created = session.get('created_at', 'Unknown')
+        if created != 'Unknown':
+            try:
+                dt = datetime.fromisoformat(created.replace('Z', '+00:00'))
+                created = dt.strftime('%Y-%m-%d %H:%M')
+            except:
+                pass
+        
+        print(f"{i:<4} {session['session_id'][:50]:<50} {created:<20} {session['message_count']:<10} {session['first_user_message'][:50]:<50}")
+
+def view_session(manager: ChatSessionManager, session_id: str):
+    """View a specific chat session"""
+    session_path = manager.base_path / session_id
+    
+    if not session_path.exists():
+        print(f"Error: Session '{session_id}' not found.")
+        return
+    
+    messages = manager.load_conversation(session_path)
+    
+    if not messages:
+        print("No messages found in this session.")
+        return
+    
+    print(f"\n=== Chat Session: {session_id} ===\n")
+    
+    for msg in messages:
+        role = msg['role'].upper()
+        content = msg['content']
+        timestamp = msg.get('timestamp', '')
+        
+        if timestamp:
+            try:
+                dt = datetime.fromisoformat(timestamp.replace('Z', '+00:00'))
+                timestamp = dt.strftime(' [%Y-%m-%d %H:%M:%S]')
+            except:
+                timestamp = ''
+        
+        print(f"{role}{timestamp}:")
+        print(f"{content}")
+        print("-" * 80)
+
+def export_session(manager: ChatSessionManager, session_id: str, output_format: str, output_file: str = None):
+    """Export a chat session to different formats"""
+    session_path = manager.base_path / session_id
+    
+    if not session_path.exists():
+        print(f"Error: Session '{session_id}' not found.")
+        return
+    
+    conversation_file = session_path / "conversation.json"
+    
+    if not conversation_file.exists():
+        print("No conversation file found in this session.")
+        return
+    
+    with open(conversation_file, 'r', encoding='utf-8') as f:
+        data = json.load(f)
+    
+    if output_file is None:
+        output_file = f"{session_id}.{output_format}"
+    
+    if output_format == 'json':
+        # Pretty print JSON
+        with open(output_file, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+    
+    elif output_format == 'txt':
+        # Export as plain text
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(f"Chat Session: {data.get('session_id', 'Unknown')}\n")
+            f.write(f"Created: {data.get('created_at', 'Unknown')}\n")
+            f.write(f"Last Updated: {data.get('last_updated', 'Unknown')}\n")
+            f.write("=" * 80 + "\n\n")
+            
+            for msg in data.get('messages', []):
+                role = msg['role'].upper()
+                content = msg['content']
+                timestamp = msg.get('timestamp', '')
+                
+                if timestamp:
+                    f.write(f"\n[{timestamp}] ")
+                f.write(f"{role}:\n{content}\n")
+                f.write("-" * 80 + "\n")
+    
+    elif output_format == 'md':
+        # Export as Markdown
+        with open(output_file, 'w', encoding='utf-8') as f:
+            f.write(f"# Chat Session: {data.get('session_id', 'Unknown')}\n\n")
+            f.write(f"**Created:** {data.get('created_at', 'Unknown')}  \n")
+            f.write(f"**Last Updated:** {data.get('last_updated', 'Unknown')}\n\n")
+            f.write("---\n\n")
+            
+            for msg in data.get('messages', []):
+                role = msg['role']
+                content = msg['content']
+                timestamp = msg.get('timestamp', '')
+                
+                if role == 'system':
+                    f.write(f"### System Prompt\n\n{content}\n\n")
+                elif role == 'user':
+                    f.write(f"### User")
+                    if timestamp:
+                        f.write(f" _{timestamp}_")
+                    f.write(f"\n\n{content}\n\n")
+                elif role == 'assistant':
+                    f.write(f"### Assistant")
+                    if timestamp:
+                        f.write(f" _{timestamp}_")
+                    f.write(f"\n\n{content}\n\n")
+                
+                f.write("---\n\n")
+    
+    print(f"Session exported to: {output_file}")
+
+def clean_sessions(manager: ChatSessionManager, days: int):
+    """Clean up sessions older than specified days"""
+    print(f"\nCleaning up sessions older than {days} days...")
+    manager.clear_old_sessions(days)
+    print("Cleanup complete.")
+
+def main():
+    parser = argparse.ArgumentParser(description='Manage OpenRouter chat sessions')
+    
+    # Create subparsers for different commands
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+    
+    # List command
+    list_parser = subparsers.add_parser('list', help='List all chat sessions')
+    list_parser.add_argument('-l', '--limit', type=int, help='Limit number of sessions to display')
+    
+    # View command
+    view_parser = subparsers.add_parser('view', help='View a specific chat session')
+    view_parser.add_argument('session_id', help='Session ID to view')
+    
+    # Export command
+    export_parser = subparsers.add_parser('export', help='Export a chat session')
+    export_parser.add_argument('session_id', help='Session ID to export')
+    export_parser.add_argument('-f', '--format', choices=['json', 'txt', 'md'], 
+                              default='txt', help='Export format (default: txt)')
+    export_parser.add_argument('-o', '--output', help='Output filename')
+    
+    # Clean command
+    clean_parser = subparsers.add_parser('clean', help='Clean up old sessions')
+    clean_parser.add_argument('-d', '--days', type=int, default=30, 
+                             help='Remove sessions older than this many days (default: 30)')
+    
+    args = parser.parse_args()
+    
+    # Initialize chat manager
+    manager = ChatSessionManager()
+    
+    if args.command == 'list':
+        list_sessions(manager, args.limit)
+    elif args.command == 'view':
+        view_session(manager, args.session_id)
+    elif args.command == 'export':
+        export_session(manager, args.session_id, args.format, args.output)
+    elif args.command == 'clean':
+        clean_sessions(manager, args.days)
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+if __name__ == '__main__':
+    main()

custom_nodes/openrouter_node/node.py

@@ -0,0 +1,748 @@
+import requests
+import json
+import time
+import base64
+import io
+import numpy as np
+import torch
+import tiktoken
+from PIL import Image
+import hashlib # Added for hashing PDF bytes in IS_CHANGED
+import os
+from .chat_manager import ChatSessionManager
+
+# Define a placeholder type name for PDF data.
+# The actual input connection will accept '*' but we check the structure.
+# Expecting a dictionary: {"filename": str, "bytes": bytes}
+PDF_DATA_TYPE = "*" # Use '*' to accept any type, check structure later
+
+class OpenRouterNode:
+    """
+    A node for interacting with OpenRouter's chat/completion API.
+    Supports text, images, and PDFs as input.
+    Returns three outputs:
+      1) "Output": the text response from the LLM
+      2) "Stats": a string detailing tokens per second, input tokens, and output tokens
+      3) "Credits": a string showing your remaining OpenRouter account balance
+    """
+
+    models_cache = None
+    last_fetch_time = 0
+    cache_duration = 3600  # Cache duration in seconds (1 hour)
+    default_request_timeout = 120
+    min_request_timeout = 1
+    max_request_timeout = 3600
+    reasoning_effort_options = ("auto", "none", "minimal", "low", "medium", "high", "xhigh")
+    default_reasoning_effort = "auto"
+
+    def __init__(self):
+        self.chat_manager = ChatSessionManager()
+
+    @staticmethod
+    def get_api_key(api_key_ui):
+        """
+        Resolves the API key from:
+        1. UI input field (if not empty)
+        2. Environment variable 'LLM_KEY'
+        3. config file 'openrouter_api_key.json' in node directory
+        """
+        if api_key_ui and api_key_ui.strip():
+            return api_key_ui.strip()
+
+        # Check environment variable
+        env_key = os.environ.get("LLM_KEY")
+        if env_key and env_key.strip():
+            return env_key.strip()
+
+        # Check JSON file
+        config_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), "openrouter_api_key.json")
+        if os.path.exists(config_path):
+            try:
+                with open(config_path, 'r') as f:
+                    config = json.load(f)
+                    file_key = config.get("api_key")
+                    if file_key and file_key.strip():
+                        return file_key.strip()
+            except Exception as e:
+                print(f"Error reading openrouter_api_key.json: {e}")
+
+        return ""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        """
+        Defines the input specification for this node.
+        Includes optional inputs for image and PDF data.
+        """
+        return {
+            "required": {
+                "api_key": ("STRING", {
+                    "multiline": False,
+                    "default": ""
+                }),
+                "system_prompt": ("STRING", {
+                    "multiline": True,
+                    "default": "You are a helpful assistant."
+                }),
+                "user_message_box": ("STRING", {
+                    "multiline": True,
+                    "default": "Hello, how are you?"
+                }),
+                "model": (cls.fetch_openrouter_models(),),
+                "web_search": ("BOOLEAN", {"default": False}),
+                "cheapest": ("BOOLEAN", {"default": True}),
+                "fastest": ("BOOLEAN", {"default": False}),
+                "aspect_ratio": ([
+                    "auto",
+                    "1:1 (1024x1024)",
+                    "2:3 (832x1248)",
+                    "3:2 (1248x832)",
+                    "3:4 (864x1184)",
+                    "4:3 (1184x864)",
+                    "4:5 (896x1152)",
+                    "5:4 (1152x896)",
+                    "9:16 (768x1344)",
+                    "16:9 (1344x768)",
+                    "21:9 (1536x672)",
+                    "1:4 (google/gemini-3.1-flash-image-preview (Nano Banana 2) only)",
+                    "4:1 (google/gemini-3.1-flash-image-preview (Nano Banana 2) only)",
+                    "1:8 (google/gemini-3.1-flash-image-preview (Nano Banana 2) only)",
+                    "8:1 (google/gemini-3.1-flash-image-preview (Nano Banana 2) only)",
+                ], {"default": "auto"}),
+                "image_resolution": (["1K", "2K", "4K"], {"default": "1K"}),
+                "reasoning_effort": (list(cls.reasoning_effort_options), {"default": cls.default_reasoning_effort}),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff, "control_after_generate": "fixed"}),
+                "temperature": ("FLOAT", {
+                    "default": 1.0,
+                    "min": 0.0,
+                    "max": 2.0,
+                    "step": 0.01,
+                    "display": "slider",
+                    "round": 0.01,
+                }),
+                 "pdf_engine": (["auto", "mistral-ocr", "pdf-text"], {"default": "auto"}),
+                "chat_mode": ("BOOLEAN", {"default": False}),
+                "request_timeout": ("INT", {
+                    "default": cls.default_request_timeout,
+                    "min": cls.min_request_timeout,
+                    "max": cls.max_request_timeout,
+                    "step": 1,
+                    "display": "number",
+                }),
+            },
+            "optional": {
+                "pdf_data": (PDF_DATA_TYPE,), # Use '*' and check structure in generate_response
+                "user_message_input": ("STRING", {"forceInput": True}),
+            }
+        }
+
+    RETURN_TYPES = ("STRING", "IMAGE", "STRING", "STRING",)
+    RETURN_NAMES = ("Output", "image", "Stats", "Credits")
+
+    FUNCTION = "generate_response"
+    CATEGORY = "LLM"
+
+    @classmethod
+    def fetch_openrouter_models(cls):
+        """
+        Fetches a list of model IDs from the OpenRouter API, caching them.
+        """
+        current_time = time.time()
+        if (cls.models_cache is None) or (current_time - cls.last_fetch_time > cls.cache_duration):
+            url = "https://openrouter.ai/api/v1/models"
+            try:
+                response = requests.get(url, timeout=cls.default_request_timeout)
+                response.raise_for_status()
+                models = response.json()["data"]
+                # Filter for models that support chat completions if needed, but API handles this
+                model_list = sorted([model['id'] for model in models])
+                cls.models_cache = model_list
+                cls.last_fetch_time = current_time
+            except requests.exceptions.RequestException as e:
+                print(f"Error fetching models: {e}")
+                # Provide a default list or indicate error if cache is empty
+                if cls.models_cache is None:
+                    cls.models_cache = ["error_fetching_models", "google/gemma-3-27b-it", "openai/gpt-4o"] # Example fallbacks
+        return cls.models_cache if cls.models_cache else ["error_fetching_models"] # Ensure it's never empty
+
+    def validate_temperature(self, temperature):
+        """
+        Validates and converts temperature value to float within acceptable range.
+        """
+        try:
+            temp = float(temperature)
+            return max(0.0, min(2.0, temp))  # Clamp between 0.0 and 2.0
+        except (ValueError, TypeError):
+            return 1.0  # Return default if conversion fails
+
+    def validate_request_timeout(self, request_timeout):
+        """
+        Validates and converts request timeout to seconds within an acceptable range.
+        """
+        try:
+            timeout = int(request_timeout)
+            return max(self.min_request_timeout, min(self.max_request_timeout, timeout))
+        except (ValueError, TypeError):
+            return self.default_request_timeout
+
+    @classmethod
+    def validate_reasoning_effort(cls, reasoning_effort):
+        """
+        Validates OpenRouter reasoning effort. "auto" means do not send a
+        reasoning override and let OpenRouter/model defaults apply.
+        """
+        if isinstance(reasoning_effort, str):
+            normalized_effort = reasoning_effort.strip().lower()
+            if normalized_effort in cls.reasoning_effort_options:
+                return normalized_effort
+        return cls.default_reasoning_effort
+
+    def fetch_credits(self, api_key, timeout=None):
+        """
+        Fetches the user's credits information from the OpenRouter API.
+        Returns a formatted string with remaining credits.
+        """
+        api_key = self.get_api_key(api_key)
+        if not api_key:
+             return "API Key not provided."
+
+        url = "https://openrouter.ai/api/v1/credits"
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://github.com/yourusername/comfyui-openrouter",
+            "X-Title": "ComfyUI OpenRouter LLM Node",
+        }
+
+        try:
+            validated_timeout = self.validate_request_timeout(timeout)
+            response = requests.get(url, headers=headers, timeout=validated_timeout)
+            response.raise_for_status()
+
+            result = response.json()
+            # Check if 'data' and expected keys exist
+            if "data" in result and "total_credits" in result["data"] and "total_usage" in result["data"]:
+                total_credits = result["data"]["total_credits"]
+                total_usage = result["data"]["total_usage"]
+                remaining = total_credits - total_usage
+                credits_text = f"Remaining: ${remaining:.3f}"
+            else:
+                credits_text = "Could not parse credit data from response."
+
+            return credits_text
+
+        except requests.exceptions.RequestException as e:
+            # Provide more context about the error
+            error_message = f"Error fetching credits: {str(e)}"
+            if hasattr(e, 'response') and e.response is not None:
+                 error_message += f" | Status Code: {e.response.status_code} | Response: {e.response.text[:200]}" # Log part of response
+            return error_message
+        except json.JSONDecodeError:
+             return "Error fetching credits: Could not decode JSON response."
+
+    def generate_response(self, api_key, system_prompt, user_message_box, model,
+                         web_search, cheapest, fastest, temperature, pdf_engine, chat_mode,
+                         request_timeout=120, aspect_ratio="auto", image_resolution="1K", seed=0,
+                         pdf_data=None, user_message_input=None, reasoning_effort="auto", **kwargs):
+        """
+        Sends a completion request to the OpenRouter chat completion endpoint.
+        Handles text, optional image, and optional PDF inputs.
+
+        Returns four outputs:
+          (1) Output: the LLM's text response
+          (2) image: an image tensor if the response contains an image, else empty tensor
+          (3) Stats: a string with tokens per second, prompt tokens, completion tokens
+          (4) Credits: a string with the user's credit information
+        """
+        # Create empty placeholder image
+        placeholder_image = torch.zeros((1, 1, 1, 3), dtype=torch.float32)
+        
+        # Resolve API key
+        api_key = self.get_api_key(api_key)
+        
+        if not api_key:
+             return ("Error: API Key not provided. Set LLM_KEY env var or use openrouter_api_key.json", placeholder_image, "Stats N/A", "Credits N/A")
+
+        url = "https://openrouter.ai/api/v1/chat/completions"
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://github.com/yourusername/comfyui-openrouter",
+            "X-Title": "ComfyUI OpenRouter LLM Node",
+        }
+
+        # Validate and convert temperature
+        validated_temp = self.validate_temperature(temperature)
+        validated_timeout = self.validate_request_timeout(request_timeout)
+        validated_reasoning_effort = self.validate_reasoning_effort(reasoning_effort)
+
+        # Decide whether to use user_message_input or user_message_box
+        user_text = user_message_input if user_message_input is not None and user_message_input.strip() else user_message_box
+
+        # Initialize session_path
+        session_path = None
+        
+        # Handle chat mode
+        if chat_mode:
+            # Get or create a chat session
+            session_path, messages = self.chat_manager.get_or_create_session(user_text, system_prompt)
+            
+            # Check if we need to update the system prompt (for existing sessions)
+            if messages and messages[0]["role"] == "system" and messages[0]["content"] != system_prompt:
+                # Update system prompt if it has changed
+                messages[0]["content"] = system_prompt
+        else:
+            # Non-chat mode: Build the messages array, starting with a system prompt.
+            messages = [
+                {"role": "system", "content": system_prompt},
+            ]
+
+        # --- Build the user message content ---
+        user_content_blocks = []
+
+        # 1. Add Text part (always present)
+        user_content_blocks.append({
+            "type": "text",
+            "text": user_text
+        })
+
+        # 2. Add Image parts (optional) - support multiple images from kwargs
+        # Process all image_N inputs from kwargs
+        image_keys = sorted([k for k in kwargs.keys() if k.startswith('image_')], 
+                           key=lambda x: int(x.split('_')[1]))
+        
+        for image_key in image_keys:
+            if kwargs[image_key] is not None:
+                try:
+                    img_str = self.image_to_base64(kwargs[image_key])
+                    user_content_blocks.append({
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/png;base64,{img_str}"
+                        }
+                    })
+                except Exception as e:
+                    print(f"Error processing {image_key}: {e}")
+                    return (f"Error processing {image_key}: {e}", placeholder_image, "Stats N/A", "Credits N/A")
+
+        # 3. Add PDF part (optional)
+        pdf_filename = "document.pdf" # Default filename if not provided
+        if pdf_data is not None:
+            # Validate pdf_data structure (expecting dict with 'filename' and 'bytes')
+            if isinstance(pdf_data, dict) and "bytes" in pdf_data and isinstance(pdf_data["bytes"], bytes):
+                pdf_bytes = pdf_data["bytes"]
+                # Use provided filename if available and valid, otherwise use default
+                if "filename" in pdf_data and isinstance(pdf_data["filename"], str) and pdf_data["filename"].strip():
+                     pdf_filename = pdf_data["filename"]
+
+                try:
+                    base64_pdf = base64.b64encode(pdf_bytes).decode('utf-8')
+                    data_url = f"data:application/pdf;base64,{base64_pdf}"
+                    user_content_blocks.append({
+                        "type": "file",
+                        "file": {
+                            "filename": pdf_filename,
+                            "file_data": data_url
+                        }
+                    })
+                except Exception as e:
+                    print(f"Error encoding PDF: {e}")
+                    return (f"Error encoding PDF: {e}", placeholder_image, "Stats N/A", "Credits N/A")
+            else:
+                # Handle case where pdf_data is not in the expected format
+                print(f"Warning: pdf_data input is not in the expected format (dict with 'filename' and 'bytes'). PDF not included.")
+                # Optionally return an error or just proceed without the PDF
+                # return ("Error: Invalid PDF data format.", "Stats N/A", "Credits N/A")
+
+
+        # Determine message format based on content type
+        # Use simple string format for text-only requests to ensure compatibility
+        # Use structured format only when we have multimodal content
+        has_multimodal_content = len(user_content_blocks) > 1 or any(block.get("type") != "text" for block in user_content_blocks)
+        
+        if has_multimodal_content:
+            # Use structured format for multimodal content
+            new_user_message = {
+                "role": "user",
+                "content": user_content_blocks
+            }
+        else:
+            # Use simple string format for text-only requests
+            new_user_message = {
+                "role": "user",
+                "content": user_text
+            }
+        
+        if chat_mode:
+            # In chat mode, append to existing conversation (but don't save yet - wait for response)
+            messages.append(new_user_message)
+        else:
+            # In non-chat mode, messages array already has system prompt, just append user message
+            messages.append(new_user_message)
+
+        # --- Apply model modifiers ---
+        modified_model = model
+        # Check if model already has modifiers to avoid duplication
+        if web_search and ":online" not in modified_model:
+            modified_model = f"{modified_model}:online"
+        if ":online" not in modified_model:
+             if cheapest and ":floor" not in modified_model:
+                 modified_model = f"{modified_model}:floor"
+             elif fastest and not cheapest and ":nitro" not in modified_model:
+                 modified_model = f"{modified_model}:nitro"
+
+
+        # --- Construct the final payload ---
+        data = {
+            "model": modified_model,
+            "messages": messages,
+            "temperature": validated_temp,
+            "seed": seed
+        }
+        if validated_reasoning_effort != "auto":
+            data["reasoning"] = {"effort": validated_reasoning_effort}
+
+        print(f"Payload: model={modified_model}")
+
+        # Add plugins if a specific PDF engine is selected
+        if pdf_engine != "auto":
+             data["plugins"] = [
+                 {
+                     "id": "file-parser",
+                     "pdf": {
+                         "engine": pdf_engine
+                     }
+                 }
+             ]
+
+        # --- Pre-calculate text input tokens (rough estimate) ---
+        # Note: Actual token count depends on the model and includes parsed PDF/image data.
+        # Rely on the API response for accurate usage stats.
+        text_token_estimate = 0
+        try:
+            text_token_estimate = self.count_tokens(system_prompt, model) + self.count_tokens(user_text, model)
+        except Exception as e:
+            print(f"Warning: Token counting failed - {e}")
+
+
+        # --- Make API Call and Process Response ---
+        try:
+            start_time = time.time()
+            response = requests.post(url, headers=headers, json=data, timeout=validated_timeout)
+            response.raise_for_status() # Raises HTTPError for bad responses (4xx or 5xx)
+            end_time = time.time()
+
+            result = response.json()
+            # Debug: print truncated response to see what OpenRouter returned
+            debug_str = json.dumps(result, default=str)
+            print(f"API response ({len(debug_str)} chars): {debug_str[:500]}")
+
+            # --- Extract results and calculate stats ---
+            if not result.get("choices") or not result["choices"][0].get("message"):
+                 raise ValueError("Invalid response format from API: 'choices' or 'message' missing.")
+
+            # Parse response for text and image content
+            message = result["choices"][0]["message"]
+            text_output = message.get("content", "")
+            image_tensor = placeholder_image
+
+            # Check for images in the separate images field (OpenRouter format)
+            if message.get("images"):
+                print(f"Found {len(message['images'])} image(s) in API response")
+                try:
+                    # Get the first image from the images array
+                    first_image = message["images"][0]
+                    image_url = first_image["image_url"]["url"]
+                    
+                    if image_url.startswith("data:image"):
+                        base64_str = image_url.split(",", 1)[1]
+                        try:
+                            # Convert base64 to image tensor
+                            image_tensor = self.base64_to_image(base64_str)
+                            print(f"Successfully decoded image from API response")
+                        except Exception as e:
+                            print(f"Error decoding image: {e}")
+                    else:
+                        print(f"Image URL format not supported: {image_url[:50]}...")
+                except Exception as e:
+                    print(f"Error processing images from response: {e}")
+            else:
+                print("No images found in API response - this may be normal if the model doesn't support image generation or the prompt didn't request an image")
+            
+            # Also handle legacy multimodal content format as fallback
+            if isinstance(text_output, list):
+                text_parts = []
+                for content in text_output:
+                    if isinstance(content, dict):
+                        if content.get("type") == "text":
+                            text_parts.append(content.get("text", ""))
+                        elif content.get("type") == "image_url":
+                            # Extract base64 image data
+                            image_url = content["image_url"]["url"]
+                            if image_url.startswith("data:image"):
+                                base64_str = image_url.split(",", 1)[1]
+                                try:
+                                    # Convert base64 to image tensor
+                                    image_tensor = self.base64_to_image(base64_str)
+                                except Exception as e:
+                                    print(f"Error decoding image: {e}")
+                text_output = "\n".join(text_parts)
+
+            response_ms = result.get("response_ms", None)
+            api_usage = result.get("usage", {})
+            prompt_tokens = api_usage.get("prompt_tokens", text_token_estimate) # Use API value if available
+            completion_tokens = api_usage.get("completion_tokens", 0)
+            if completion_tokens == 0 and text_output: # Estimate completion tokens if API doesn't provide them
+                 try:
+                     completion_tokens = self.count_tokens(text_output, model)
+                 except Exception as e:
+                     print(f"Warning: Completion token counting failed - {e}")
+
+
+            # Calculate tokens per second (TPS)
+            tps = 0
+            elapsed_time = end_time - start_time
+            if response_ms is not None:
+                server_elapsed_time = response_ms / 1000.0
+                if server_elapsed_time > 0:
+                    tps = completion_tokens / server_elapsed_time
+            elif elapsed_time > 0:
+                # Use client-side timing as fallback, less accurate due to network latency
+                 tps = completion_tokens / elapsed_time
+                 # Optional: apply a heuristic correction factor if needed, but server time is better
+                 # correction_factor = 1.28 # Example factor, might need tuning
+                 # tps *= correction_factor
+
+            stats_text = (
+                f"TPS: {tps:.2f}, "
+                f"Prompt Tokens: {prompt_tokens}, "
+                f"Completion Tokens: {completion_tokens}, "
+                f"Temp: {validated_temp:.1f}, "
+                f"Model: {modified_model}" # Display the actual model used
+            )
+            if pdf_engine != "auto":
+                 stats_text += f", PDF Engine: {pdf_engine}"
+            if validated_reasoning_effort != "auto":
+                 stats_text += f", Reasoning: {validated_reasoning_effort}"
+
+
+            # Fetch credits information AFTER the main request
+            credits_text = self.fetch_credits(api_key, timeout=validated_timeout)
+
+            # Save conversation in chat mode
+            if chat_mode and session_path:
+                # Append assistant's response to the conversation
+                assistant_message = {
+                    "role": "assistant",
+                    "content": text_output
+                }
+                messages.append(assistant_message)
+                
+                # Save the updated conversation
+                self.chat_manager.save_conversation(session_path, messages)
+
+            return (text_output, image_tensor, stats_text, credits_text)
+
+        except requests.exceptions.RequestException as e:
+            error_message = f"API Request Error: {str(e)}"
+            if hasattr(e, 'response') and e.response is not None:
+                try:
+                    error_detail = e.response.json()
+                    error_message += f" | Details: {error_detail}"
+                except json.JSONDecodeError:
+                    error_message += f" | Status: {e.response.status_code} | Response: {e.response.text[:200]}"
+            else:
+                 error_message += " (Network or connection issue)"
+            print(f"ERROR: {error_message}")
+            return (error_message, placeholder_image, "Stats N/A due to error", "Credits N/A due to error")
+        except Exception as e:
+             print(f"ERROR: Node Error: {str(e)}")
+             return (f"Node Error: {str(e)}", placeholder_image, "Stats N/A due to error", "Credits N/A due to error")
+
+    @staticmethod
+    def image_to_base64(image):
+        """
+        Converts a ComfyUI IMAGE (torch.Tensor, BHWC, float 0-1)
+        into a base64-encoded PNG string.
+        """
+        if not isinstance(image, torch.Tensor):
+            raise TypeError("Input 'image' is not a torch.Tensor")
+
+        # Remove batch dimension if present
+        if image.ndim == 4:
+            if image.shape[0] != 1:
+                 print(f"Warning: Image batch size is {image.shape[0]}, using only the first image.")
+            image = image.squeeze(0) # Shape HWC
+
+        if image.ndim != 3:
+             raise ValueError(f"Unexpected image dimensions: {image.shape}. Expected HWC.")
+
+        # Convert float tensor (0-1) to numpy array (0-255, uint8)
+        image_np = image.cpu().numpy()
+        if image_np.dtype != np.uint8:
+             if image_np.min() < 0 or image_np.max() > 1:
+                  print("Warning: Image tensor values outside [0, 1] range. Clamping.")
+                  image_np = np.clip(image_np, 0, 1)
+             image_np = (image_np * 255).astype(np.uint8)
+
+        # Convert numpy array to PIL Image
+        pil_image = Image.fromarray(image_np, 'RGB') # Assuming RGB, adjust if needed
+
+        # Save PIL Image to a bytes buffer as PNG
+        buffered = io.BytesIO()
+        pil_image.save(buffered, format="PNG")
+
+        # Encode the bytes buffer to base64 string
+        return base64.b64encode(buffered.getvalue()).decode('utf-8')
+
+    @staticmethod
+    def base64_to_image(base64_str: str) -> torch.Tensor:
+        """
+        Converts a base64 image string to a ComfyUI image tensor
+        Returns tensor in [1, H, W, 3] format with values in [0, 1]
+        """
+        try:
+            # Decode base64 string to image
+            img_data = base64.b64decode(base64_str)
+            img = Image.open(io.BytesIO(img_data))
+            img = img.convert("RGB")
+
+            # Convert to numpy array and normalize to [0, 1]
+            img_array = np.array(img).astype(np.float32) / 255.0
+            
+            # Add batch dimension: [1, H, W, 3]
+            img_tensor = torch.from_numpy(img_array).unsqueeze(0)
+            
+            print(f"Successfully converted base64 to image tensor: {img_tensor.shape}")
+            return img_tensor
+            
+        except Exception as e:
+            print(f"Error in base64_to_image: {e}")
+            # Return a small placeholder image instead of failing
+            return torch.zeros((1, 64, 64, 3), dtype=torch.float32)
+
+    @staticmethod
+    def count_tokens(text, model):
+        """
+        Count tokens for a given text using tiktoken.
+        Uses model-specific encodings where possible, falls back to cl100k_base.
+        Handles potential errors during encoding.
+        """
+        if not text or not isinstance(text, str):
+            return 0
+
+        # Strip any model modifiers like :floor, :nitro, :online
+        base_model = model.split(':')[0] if ':' in model else model
+
+        # Simplified mapping, cl100k_base is common for many recent models
+        encoding_name = "cl100k_base"
+        try:
+            # List known models/prefixes that definitely use cl100k_base
+            # Add others if known, but cl100k_base is a safe default for many
+            cl100k_models = [
+                "openai/gpt-4", "openai/gpt-3.5", "openai/gpt-4o",
+                "anthropic/claude",
+                "google/gemini",
+                "meta-llama/llama-2", "meta-llama/llama-3",
+                "mistralai/mistral", "mistralai/mixtral",
+            ]
+            # Check if the base_model or its prefix matches known cl100k models
+            is_cl100k = any(base_model.startswith(prefix) for prefix in cl100k_models)
+
+            if is_cl100k:
+                 encoding_name = "cl100k_base"
+            # else: # Add logic for other encodings if needed, e.g., p50k_base for older models
+            #    pass # Stick with cl100k_base as default for now
+
+            encoding = tiktoken.get_encoding(encoding_name)
+            token_count = len(encoding.encode(text, disallowed_special=())) # Allow special tokens
+            return token_count
+
+        except Exception as e:
+            print(f"Warning: Tiktoken error for model '{model}' (base: '{base_model}', encoding: '{encoding_name}'): {e}. Falling back to estimation.")
+            # Fallback: Estimate tokens based on characters (rough approximation)
+            # Average ~4 chars per token is a common heuristic
+            return max(1, round(len(text) / 4))
+
+
+    @classmethod
+    def IS_CHANGED(cls, api_key, system_prompt, user_message_box, model,
+                   web_search, cheapest, fastest, temperature, pdf_engine, chat_mode,
+                   request_timeout=120, aspect_ratio="auto", image_resolution="1K", seed=0,
+                   pdf_data=None, user_message_input=None, reasoning_effort="auto", **kwargs):
+        """
+        Check if any input that affects the output has changed.
+        Includes hashing image and PDF data.
+        """
+        # Hash image data if present - handle multiple images from kwargs
+        image_hashes = []
+        image_keys = sorted([k for k in kwargs.keys() if k.startswith('image_')], 
+                           key=lambda x: int(x.split('_')[1]))
+        
+        for image_key in image_keys:
+            if kwargs[image_key] is not None:
+                image = kwargs[image_key]
+                if isinstance(image, torch.Tensor):
+                    try:
+                        hasher = hashlib.sha256()
+                        hasher.update(image.cpu().numpy().tobytes())
+                        image_hashes.append(hasher.hexdigest())
+                    except Exception as e:
+                        print(f"Warning: Could not hash {image_key} data for IS_CHANGED: {e}")
+                        image_hashes.append(f"{image_key}_hashing_error")
+                else:
+                    image_hashes.append(None)
+
+
+        # Hash PDF data if present and valid
+        pdf_hash = None
+        if pdf_data is not None and isinstance(pdf_data, dict) and "bytes" in pdf_data and isinstance(pdf_data["bytes"], bytes):
+             try:
+                 hasher = hashlib.sha256()
+                 hasher.update(pdf_data["bytes"])
+                 pdf_hash = hasher.hexdigest()
+                 # Optionally include filename in hash if it affects processing?
+                 # if "filename" in pdf_data: hasher.update(pdf_data["filename"].encode())
+             except Exception as e:
+                 print(f"Warning: Could not hash pdf data for IS_CHANGED: {e}")
+                 pdf_hash = "pdf_hashing_error" # Use a placeholder on error
+        elif pdf_data is not None:
+             # Handle cases where pdf_data is present but not in the expected format
+             pdf_hash = "invalid_pdf_data_format"
+
+
+        # Ensure temperature is consistently represented (e.g., as float)
+        try:
+            temp_float = float(temperature) if isinstance(temperature, (str, int, float)) else 1.0
+            temp_float = max(0.0, min(2.0, temp_float))
+        except (ValueError, TypeError):
+            temp_float = 1.0
+
+        try:
+            timeout_int = int(request_timeout)
+            timeout_int = max(cls.min_request_timeout, min(cls.max_request_timeout, timeout_int))
+        except (ValueError, TypeError):
+            timeout_int = cls.default_request_timeout
+
+        validated_reasoning_effort = cls.validate_reasoning_effort(reasoning_effort)
+
+
+        # Combine all relevant inputs into a tuple for comparison
+        # Use primitive types where possible for reliable hashing/comparison
+        # Note: api_key here is the UI value only. Keys resolved from the LLM_KEY
+        # env var or openrouter_api_key.json are intentionally NOT part of the
+        # cache key — they're treated as user environment, not workflow inputs.
+        return (api_key, system_prompt, user_message_box, model,
+                web_search, cheapest, fastest, temp_float, pdf_engine, chat_mode,
+                timeout_int, aspect_ratio, image_resolution, seed, validated_reasoning_effort,
+                tuple(image_hashes), pdf_hash, user_message_input)
+
+# Node class mappings
+NODE_CLASS_MAPPINGS = {
+    "OpenRouterNode": OpenRouterNode
+}
+
+# Node display name mappings
+NODE_DISPLAY_NAME_MAPPINGS = {
+    "OpenRouterNode": "OpenRouter LLM Node (Text/Multi-Image/PDF/Chat)" # Updated name
+}

custom_nodes/openrouter_node/openrouter_api_key.json.example

@@ -0,0 +1,3 @@
+{
+    "api_key": "your_openrouter_api_key_here"
+}

custom_nodes/openrouter_node/pyproject.toml

@@ -0,0 +1,15 @@
+[project]
+name = "openrouter_node"
+description = "A custom node for ComfyUI that allows you to interact with OpenRouter's chat/completion API, providing access to a wide range of models."
+version = "1.0.2"
+license = {file = "LICENSE"}
+dependencies = ["requests", "tiktoken", "Pillow"]
+
+[project.urls]
+Repository = "https://github.com/gabe-init/ComfyUI-Openrouter_node"
+#  Used by Comfy Registry https://comfyregistry.org
+
+[tool.comfy]
+PublisherId = "gabe-init"
+DisplayName = "ComfyUI-Openrouter_node"
+Icon = ""

custom_nodes/openrouter_node/requirements.txt

@@ -0,0 +1,2 @@
+tiktoken  # accurate LLM token counting
+Pillow    # image processing

custom_nodes/openrouter_node/tests/__init__.py

@@ -0,0 +1 @@
+

custom_nodes/openrouter_node/tests/test_request_timeout.py

@@ -0,0 +1,204 @@
+import importlib.util
+import sys
+import types
+import unittest
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+
+class FakeRequestException(Exception):
+    def __init__(self, message="", response=None):
+        super().__init__(message)
+        self.response = response
+
+
+class FakeTimeout(FakeRequestException):
+    pass
+
+
+def install_dependency_stubs():
+    requests_module = types.ModuleType("requests")
+    exceptions = types.SimpleNamespace(
+        RequestException=FakeRequestException,
+        Timeout=FakeTimeout,
+    )
+    requests_module.exceptions = exceptions
+    requests_module.get = Mock()
+    requests_module.post = Mock()
+    sys.modules["requests"] = requests_module
+
+    torch_module = types.ModuleType("torch")
+    torch_module.float32 = "float32"
+    torch_module.Tensor = type("Tensor", (), {})
+    torch_module.zeros = Mock(return_value="placeholder-image")
+    sys.modules["torch"] = torch_module
+
+    tiktoken_module = types.ModuleType("tiktoken")
+    tiktoken_module.get_encoding = Mock()
+    sys.modules["tiktoken"] = tiktoken_module
+
+    pil_module = types.ModuleType("PIL")
+    image_module = types.ModuleType("PIL.Image")
+    image_module.open = Mock()
+    image_module.fromarray = Mock()
+    pil_module.Image = image_module
+    sys.modules["PIL"] = pil_module
+    sys.modules["PIL.Image"] = image_module
+
+    sys.modules.setdefault("numpy", types.ModuleType("numpy"))
+
+
+def load_node_module():
+    install_dependency_stubs()
+    root = Path(__file__).resolve().parents[1]
+    package_name = "comfy_openrouter_node_test"
+
+    package = types.ModuleType(package_name)
+    package.__path__ = [str(root)]
+    sys.modules[package_name] = package
+
+    spec = importlib.util.spec_from_file_location(
+        f"{package_name}.node",
+        root / "node.py",
+        submodule_search_locations=[str(root)],
+    )
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+class RequestTimeoutTests(unittest.TestCase):
+    def setUp(self):
+        self.node_module = load_node_module()
+        self.node = self.node_module.OpenRouterNode()
+        self.node.fetch_credits = Mock(return_value="Remaining: $1.000")
+        self.node.count_tokens = Mock(return_value=1)
+
+    def call_generate_response(self, request_timeout=120, reasoning_effort="auto"):
+        return self.node.generate_response(
+            api_key="test-key",
+            system_prompt="system",
+            user_message_box="hello",
+            model="openai/gpt-4o",
+            web_search=False,
+            cheapest=False,
+            fastest=False,
+            temperature=1.0,
+            pdf_engine="auto",
+            chat_mode=False,
+            request_timeout=request_timeout,
+            reasoning_effort=reasoning_effort,
+        )
+
+    def test_main_openrouter_request_uses_configured_timeout(self):
+        response = Mock()
+        response.raise_for_status = Mock()
+        response.json.return_value = {
+            "choices": [{"message": {"content": "done"}}],
+            "usage": {"prompt_tokens": 2, "completion_tokens": 3},
+        }
+        self.node_module.requests.post.return_value = response
+
+        result = self.call_generate_response(request_timeout=45)
+
+        self.assertEqual(result[0], "done")
+        self.node_module.requests.post.assert_called_once()
+        self.assertEqual(self.node_module.requests.post.call_args.kwargs["timeout"], 45)
+
+    def test_default_reasoning_effort_omits_reasoning_override(self):
+        response = Mock()
+        response.raise_for_status = Mock()
+        response.json.return_value = {
+            "choices": [{"message": {"content": "done"}}],
+            "usage": {"prompt_tokens": 2, "completion_tokens": 3},
+        }
+        self.node_module.requests.post.return_value = response
+
+        result = self.call_generate_response()
+
+        self.assertEqual(result[0], "done")
+        payload = self.node_module.requests.post.call_args.kwargs["json"]
+        self.assertNotIn("reasoning", payload)
+
+    def test_explicit_reasoning_effort_is_sent(self):
+        response = Mock()
+        response.raise_for_status = Mock()
+        response.json.return_value = {
+            "choices": [{"message": {"content": "done"}}],
+            "usage": {"prompt_tokens": 2, "completion_tokens": 3},
+        }
+        self.node_module.requests.post.return_value = response
+
+        result = self.call_generate_response(reasoning_effort="high")
+
+        self.assertEqual(result[0], "done")
+        payload = self.node_module.requests.post.call_args.kwargs["json"]
+        self.assertEqual(payload["reasoning"], {"effort": "high"})
+
+    def test_invalid_reasoning_effort_falls_back_to_auto(self):
+        response = Mock()
+        response.raise_for_status = Mock()
+        response.json.return_value = {
+            "choices": [{"message": {"content": "done"}}],
+            "usage": {"prompt_tokens": 2, "completion_tokens": 3},
+        }
+        self.node_module.requests.post.return_value = response
+
+        result = self.call_generate_response(reasoning_effort="unsupported")
+
+        self.assertEqual(result[0], "done")
+        payload = self.node_module.requests.post.call_args.kwargs["json"]
+        self.assertNotIn("reasoning", payload)
+
+    def test_is_changed_includes_reasoning_effort(self):
+        base_args = dict(
+            api_key="test-key",
+            system_prompt="system",
+            user_message_box="hello",
+            model="openai/gpt-4o",
+            web_search=False,
+            cheapest=False,
+            fastest=False,
+            temperature=1.0,
+            pdf_engine="auto",
+            chat_mode=False,
+            request_timeout=120,
+        )
+
+        low_key = self.node_module.OpenRouterNode.IS_CHANGED(**base_args, reasoning_effort="low")
+        high_key = self.node_module.OpenRouterNode.IS_CHANGED(**base_args, reasoning_effort="high")
+
+        self.assertNotEqual(low_key, high_key)
+
+    def test_timeout_exception_returns_clear_error(self):
+        self.node_module.requests.post.side_effect = FakeTimeout("request timed out")
+
+        result = self.call_generate_response(request_timeout=2)
+
+        self.assertIn("API Request Error", result[0])
+        self.assertIn("request timed out", result[0])
+        self.assertEqual(result[2], "Stats N/A due to error")
+        self.assertEqual(result[3], "Credits N/A due to error")
+
+    def test_fetch_credits_uses_configured_timeout(self):
+        self.node.fetch_credits = self.node_module.OpenRouterNode().fetch_credits
+        response = Mock()
+        response.raise_for_status = Mock()
+        response.json.return_value = {
+            "data": {
+                "total_credits": 10.0,
+                "total_usage": 3.25,
+            }
+        }
+        self.node_module.requests.get.return_value = response
+
+        credits = self.node.fetch_credits("test-key", timeout=45)
+
+        self.assertEqual(credits, "Remaining: $6.750")
+        self.node_module.requests.get.assert_called_once()
+        self.assertEqual(self.node_module.requests.get.call_args.kwargs["timeout"], 45)
+
+
+if __name__ == "__main__":
+    unittest.main()

custom_nodes/openrouter_node/web/openrouter_dynamic_inputs.js

@@ -0,0 +1,138 @@
+/**
+ * Dynamic image inputs for OpenRouter Node
+ * Based on cozy_ex_dynamic pattern for clean dynamic inputs
+ */
+
+import { app } from "../../../scripts/app.js"
+
+const TypeSlot = {
+    Input: 1,
+    Output: 2,
+};
+
+const TypeSlotEvent = {
+    Connect: true,
+    Disconnect: false,
+};
+
+const NODE_ID = "OpenRouterNode";
+const PREFIX = "image";
+const TYPE = "IMAGE";
+
+app.registerExtension({
+    name: 'OpenRouter.DynamicImageInputs',
+    async beforeRegisterNodeDef(nodeType, nodeData, app) {
+        // Skip if not our node
+        if (nodeData.name !== NODE_ID) {
+            return
+        }
+
+        const onNodeCreated = nodeType.prototype.onNodeCreated;
+        nodeType.prototype.onNodeCreated = function () {
+            const me = onNodeCreated?.apply(this);
+            
+            // Find api_key widget and update label with security warning
+            const apiKeyWidget = this.widgets?.find(w => w.name === "api_key");
+            if (apiKeyWidget) {
+                apiKeyWidget.label = "api_key (Leave blank for secure loading)";
+            }
+
+            // Start with a new dynamic input - exactly like cozy example
+            this.addInput(PREFIX, TYPE);
+            
+            // Ensure the new slot has proper appearance
+            const slot = this.inputs[this.inputs.length - 1];
+            if (slot) {
+                slot.color_off = "#666";
+            }
+            
+            return me;
+        }
+
+        const onConnectionsChange = nodeType.prototype.onConnectionsChange
+        nodeType.prototype.onConnectionsChange = function (slotType, slot_idx, event, link_info, node_slot) {
+            const me = onConnectionsChange?.apply(this, arguments);
+
+            if (slotType === TypeSlot.Input) {
+                // Only process image inputs
+                if (node_slot && !node_slot.name.startsWith(PREFIX)) {
+                    return me;
+                }
+                
+                if (link_info && event === TypeSlotEvent.Connect) {
+                    // Get the parent (left side node) from the link
+                    const fromNode = this.graph._nodes.find(
+                        (otherNode) => otherNode.id == link_info.origin_id
+                    )
+
+                    if (fromNode) {
+                        // Make sure there is a parent for the link
+                        const parent_link = fromNode.outputs[link_info.origin_slot];
+                        if (parent_link) {
+                            node_slot.type = parent_link.type;
+                            node_slot.name = `${PREFIX}_`;
+                        }
+                    }
+                } else if (event === TypeSlotEvent.Disconnect) {
+                    // Don't remove the slot immediately, let the cleanup below handle it
+                }
+
+                // Track each slot name so we can index the uniques
+                let idx = 0;
+                let slot_tracker = {};
+                let toRemove = [];
+                
+                for(const slot of this.inputs) {
+                    // Skip non-image inputs
+                    if (!slot.name.startsWith(PREFIX)) {
+                        idx += 1;
+                        continue;
+                    }
+                    
+                    // Mark empty image slots for removal (except the last one)
+                    if (slot.link === null && idx < this.inputs.length - 1) {
+                        toRemove.push(idx);
+                    } else if (slot.link !== null) {
+                        // Connected slot - update its name with proper index
+                        const name = slot.name.split('_')[0];
+                        let count = (slot_tracker[name] || 0) + 1;
+                        slot_tracker[name] = count;
+                        slot.name = `${name}_${count}`;
+                    }
+                    idx += 1;
+                }
+                
+                // Remove empty slots from highest index to lowest
+                toRemove.reverse();
+                for(const removeIdx of toRemove) {
+                    this.removeInput(removeIdx);
+                }
+
+                // Check if the last input is an image input
+                let lastInput = null;
+                for (let i = this.inputs.length - 1; i >= 0; i--) {
+                    if (this.inputs[i].name.startsWith(PREFIX)) {
+                        lastInput = this.inputs[i];
+                        break;
+                    }
+                }
+                
+                // If there's no empty image slot at the end, or no image slots at all, add one
+                if (!lastInput || lastInput.link !== null) {
+                    this.addInput(PREFIX, TYPE);
+                    // Set the unconnected slot to appear gray
+                    const newSlot = this.inputs[this.inputs.length - 1];
+                    if (newSlot) {
+                        newSlot.color_off = "#666";
+                    }
+                }
+
+                // Force the node to resize itself for the new/deleted connections
+                this?.graph?.setDirtyCanvas(true);
+                return me;
+            }
+        }
+        
+        return nodeType;
+    },
+})