lollms-client 1.7.13__py3-none-any.whl → 1.8.3__py3-none-any.whl

lollms_client/lollms_discussion.py

@@ -471,30 +471,156 @@ class LollmsMessage:
             if i < len(self.active_images) and self.active_images[i]
         ]
 
+    def _sync_active_images_flags(self):
+        """Re-calculates active_images boolean list based on image_groups metadata."""
+        current_images = self.images or []
+        if not current_images:
+            self.active_images = []
+            return
+
+        metadata = self.metadata or {}
+        # Support legacy key "image_generation_groups" by merging or checking both
+        groups = metadata.get("image_groups", []) + metadata.get("image_generation_groups", [])
+        
+        new_active_flags = [False] * len(current_images)
+        
+        grouped_indices = set()
+        
+        for group in groups:
+            indices = group.get("indices", [])
+            for i in indices:
+                grouped_indices.add(i)
+            
+            # Group is active by default unless explicitly False
+            is_group_active = group.get("is_active", True)
+            
+            if is_group_active:
+                main_idx = group.get("main_image_index")
+                # Fallback: if main_idx invalid, use first index
+                if main_idx is None or main_idx not in indices:
+                    if indices:
+                        main_idx = indices[0]
+                
+                if main_idx is not None and 0 <= main_idx < len(new_active_flags):
+                    new_active_flags[main_idx] = True
+        
+        # Legacy/Ungrouped images are active by default
+        for i in range(len(current_images)):
+            if i not in grouped_indices:
+                new_active_flags[i] = True
+                
+        self.active_images = new_active_flags
+
     def toggle_image_activation(self, index: int, active: Optional[bool] = None):
         """
         Toggles or sets the activation status of an image at a given index.
-        This change is committed to the database if the discussion is DB-backed.
+        This handles groups/packs: if the image belongs to a group, enabling it
+        will disable others in that group and set it as main.
         
         Args:
             index: The index of the image in the 'images' list.
-            active: If provided, sets the status to this boolean. If None, toggles the current status.
+            active: If provided, sets the status to this boolean. If None, toggles.
         """
-        if not self.images or index >= len(self.images):
-            raise IndexError("Image index out of range.")
-
-        # Initialize active_images if it's missing or mismatched
-        if self.active_images is None or not isinstance(self.active_images, list) or len(self.active_images) != len(self.images):
-            new_active_images = [True] * len(self.images)
+        metadata = (self.metadata or {}).copy()
+        groups = metadata.get("image_groups", []) + metadata.get("image_generation_groups", [])
+        
+        target_group = next((g for g in groups if index in g.get("indices", [])), None)
+        
+        if target_group:
+            # If explicit active state provided
+            if active is not None:
+                if active:
+                    target_group["is_active"] = True
+                    target_group["main_image_index"] = index
+                else:
+                    # If setting specific image to inactive
+                    if target_group.get("main_image_index") == index:
+                        target_group["is_active"] = False
+            else:
+                # Toggle logic
+                # If clicking the currently active main image -> toggle group active state
+                if target_group.get("main_image_index") == index:
+                    target_group["is_active"] = not target_group.get("is_active", True)
+                else:
+                    # Select new image and ensure group is active
+                    target_group["main_image_index"] = index
+                    target_group["is_active"] = True
+            
+            self.metadata = metadata
+            self._sync_active_images_flags()
+            
         else:
-            new_active_images = self.active_images.copy()
+            # Ungrouped image - wrap in a new single-item group to persist state
+            new_group = {
+                "id": str(uuid.uuid4()),
+                "type": "upload",
+                "indices": [index],
+                "created_at": datetime.utcnow().isoformat(),
+                "main_image_index": index,
+                "is_active": active if active is not None else not (self.active_images and self.active_images[index])
+            }
+            if "image_groups" not in metadata:
+                metadata["image_groups"] = []
+            metadata["image_groups"].append(new_group)
+            
+            self.metadata = metadata
+            self._sync_active_images_flags()
 
-        if active is None:
-            new_active_images[index] = not new_active_images[index]
-        else:
-            new_active_images[index] = bool(active) # Ensure it's a boolean
+        if self._discussion._is_db_backed:
+            self._discussion.commit()
+
+    def add_image_pack(self, images: List[str], group_type: str = "generated", active_by_default: bool = True, title: str = None) -> None:
+        """
+        Adds a list of images as a new pack/group.
+        
+        - The new images are appended to the existing images list.
+        - A new group entry is added to 'image_groups' metadata with 'main_image_index' and 'is_active'.
+        
+        Args:
+            images: List of base64 image strings.
+            group_type: Type label for the group (e.g., 'generated', 'upload').
+            active_by_default: If True, the pack is activated.
+            title: Optional title for the image pack (e.g., the prompt).
+        """
+        if not images:
+            return
+            
+        current_images = self.images or []
+        start_index = len(current_images)
+        
+        # Append new images
+        current_images.extend(images)
+        self.images = current_images
+        
+        # Update Metadata with Group info
+        metadata = (self.metadata or {}).copy()
+        groups = metadata.get("image_groups", [])
+        
+        new_indices = list(range(start_index, start_index + len(images)))
+        
+        # Default main image is the first one in the pack
+        main_image_idx = new_indices[0] if new_indices else None
+        
+        group_entry = {
+            "id": str(uuid.uuid4()),
+            "type": group_type,
+            "indices": new_indices,
+            "created_at": datetime.utcnow().isoformat(),
+            "main_image_index": main_image_idx,
+            "is_active": active_by_default
+        }
+        
+        if title:
+            group_entry["title"] = title
+        
+        groups.append(group_entry)
+        
+        metadata["image_groups"] = groups
+        self.metadata = metadata
+        
+        # Sync active_images list based on new group data
+        self._sync_active_images_flags()
         
-        self.active_images = new_active_images
         if self._discussion._is_db_backed:
             self._discussion.commit()
     
@@ -962,11 +1088,34 @@ class LollmsDiscussion:
         else:
             new_msg_orm = SimpleNamespace(**message_data)
             self._db_discussion.messages.append(new_msg_orm)
+        
+        # Wrap the new message immediately to perform updates
+        wrapped_msg = LollmsMessage(self, new_msg_orm)
+        
+        # Automatically group user uploaded images if present and not already grouped
+        images_list = kwargs.get('images', [])
+        if images_list and kwargs.get('sender_type') == 'user':
+            meta = wrapped_msg.metadata or {}
+            # Check if groups already exist (e.g. if loaded from JSON backup)
+            if not meta.get('image_groups'):
+                groups = []
+                for i in range(len(images_list)):
+                    groups.append({
+                        "id": str(uuid.uuid4()),
+                        "type": "upload",
+                        "indices": [i],
+                        "created_at": datetime.utcnow().isoformat(),
+                        "main_image_index": i,
+                        "is_active": True
+                    })
+                meta["image_groups"] = groups
+                wrapped_msg.metadata = meta
+                wrapped_msg._sync_active_images_flags()
             
         self.active_branch_id = msg_id # New message is always a leaf
         self._message_index[msg_id] = new_msg_orm
         self.touch()
-        return LollmsMessage(self, new_msg_orm)
+        return wrapped_msg
     
     def get_branch(self, leaf_id: Optional[str]) -> List[LollmsMessage]:
         """Traces a branch of the conversation from a leaf message back to the root.
@@ -1115,7 +1264,9 @@ class LollmsDiscussion:
             if user_msg_orm.sender_type != 'user':
                 raise ValueError(f"Regeneration failed: active branch tip is a '{user_msg_orm.sender_type}' message, not 'user'.")
             user_msg = LollmsMessage(self, user_msg_orm)
-            images = user_msg.images
+            # FIX: Use get_active_images() to ensure we get a list of strings, not potentially objects/dicts.
+            # This prevents errors if the underlying 'images' field contains new-style structured data.
+            images = user_msg.get_active_images()
                     
         # extract personality data
         if personality is not None:
@@ -1249,7 +1400,7 @@ class LollmsDiscussion:
                 prompt_for_chat = self.export("markdown", branch_tip_id if branch_tip_id else self.active_branch_id)
                 ASCIIColors.cyan("\n" + "="*50 + f"\n--- DEBUG: SIMPLE CHAT PROMPT ---\n{prompt_for_chat}\n" + "="*50 + "\n")
 
-            final_raw_response = self.lollmsClient.chat(self, images=images, **kwargs) or ""
+            final_raw_response = self.lollmsClient.chat(self, images=images, branch_tip_id=branch_tip_id, **kwargs) or ""
             
             if debug:
                 ASCIIColors.cyan("\n" + "="*50 + f"\n--- DEBUG: RAW SIMPLE CHAT RESPONSE ---\n{final_raw_response}\n" + "="*50 + "\n")
@@ -1299,10 +1450,8 @@ class LollmsDiscussion:
     def regenerate_branch(self, branch_tip_id: Optional[str] = None, **kwargs) -> Dict[str, Any]:
         """Regenerates the AI response for a given message or the active branch's AI response.
 
-        If the target is an AI message, it's deleted and its children are re-parented to its parent
-        (the user message). A new AI response is then generated from that user message.
-        If the target is a user message, all its existing AI children are deleted, and their
-        descendants are re-parented to the user message. A new AI response is then generated.
+        Instead of deleting the old response, this method simply starts a new generation
+        from the parent message, creating a new branch (sibling to the original response).
 
         Args:
             branch_tip_id (Optional[str]): The ID of the message to regenerate from.
@@ -1333,23 +1482,6 @@ class LollmsDiscussion:
         else:
             raise ValueError(f"Regeneration failed: Target message '{target_id}' is of an unexpected sender type '{target_message_orm.sender_type}'.")
 
-        ai_messages_to_overwrite_ids = set()
-        if target_message_orm.sender_type == 'assistant':
-            # If target is an AI, we only remove this specific AI message.
-            ai_messages_to_overwrite_ids.add(target_message_orm.id)
-        elif target_message_orm.sender_type == 'user':
-            # If target is a user, we remove ALL AI children of this user message.
-            for msg_obj in self._db_discussion.messages:
-                if msg_obj.parent_id == user_msg_to_regenerate_from.id and msg_obj.sender_type == 'assistant':
-                    ai_messages_to_overwrite_ids.add(msg_obj.id)
-        
-        if not ai_messages_to_overwrite_ids:
-            ASCIIColors.warning(f"No AI messages found to regenerate from '{target_id}'. This might be unintended.")
-            # If no AI messages to overwrite, just proceed with generation from user message.
-            # No changes to existing messages needed, so skip the cleanup phase.
-            self.active_branch_id = user_msg_to_regenerate_from.id # Ensure active branch is correct for chat
-            return self.chat(user_message="", add_user_message=False, branch_tip_id=user_msg_to_regenerate_from.id, **kwargs)
-
         # --- Phase 1: Generate new AI response ---
         # The user message for the new generation is user_msg_to_regenerate_from
         self.active_branch_id = user_msg_to_regenerate_from.id

lollms_client/lollms_mcp_binding.py

@@ -140,7 +140,6 @@ class LollmsMCPBindingManager:
         if binding_class_to_instantiate:
             try:
                 return binding_class_to_instantiate(
-                    binding_name=binding_name,
                     **kwargs
                 )
             except Exception as e:

lollms_client/lollms_stt_binding.py

@@ -88,7 +88,7 @@ class LollmsSTTBindingManager:
                     "service_key": service_key,
                     "verify_ssl_certificate": verify_ssl_certificate
                 })
-                return binding_class(binding_name=binding_name, **kwargs)
+                return binding_class(**kwargs)
             except Exception as e:
                 trace_exception(e)
                 print(f"Failed to instantiate STT binding {binding_name}: {str(e)}")

lollms_client/lollms_tti_binding.py

@@ -105,7 +105,7 @@ class LollmsTTIBindingManager:
         binding_class = self.available_bindings.get(binding_name)
         if binding_class:
             try:
-                return binding_class(binding_name=binding_name, **kwargs)
+                return binding_class(**kwargs)
             except Exception as e:
                 trace_exception(e)
                 print(f"Failed to instantiate TTI binding {binding_name}: {str(e)}")

lollms_client/lollms_ttm_binding.py

@@ -77,7 +77,7 @@ class LollmsTTMBindingManager:
         binding_class = self.available_bindings.get(binding_name)
         if binding_class:
             try:
-                return binding_class(binding_name=binding_name, **kwargs)
+                return binding_class(**kwargs)
             except Exception as e:
                 trace_exception(e)
                 print(f"Failed to instantiate TTM binding {binding_name}: {str(e)}")

lollms_client/lollms_tts_binding.py

@@ -75,7 +75,7 @@ class LollmsTTSBindingManager:
         
         binding_class = self.available_bindings.get(binding_name)
         if binding_class:
-            return binding_class(binding_name=binding_name, **kwargs)
+            return binding_class(**kwargs)
         return None
 
 

lollms_client/lollms_ttv_binding.py

@@ -76,7 +76,7 @@ class LollmsTTVBindingManager:
         binding_class = self.available_bindings.get(binding_name)
         if binding_class:
             try:
-                return binding_class(binding_name=binding_name, **kwargs)
+                return binding_class(**kwargs)
             except Exception as e:
                 trace_exception(e)
                 print(f"Failed to instantiate TTV binding {binding_name}: {str(e)}")

lollms_client/tti_bindings/open_router/__init__.py

@@ -0,0 +1,341 @@
+import requests
+import json
+import base64
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union, Callable
+from lollms_client.lollms_tti_binding import LollmsTTIBinding
+from lollms_client.lollms_types import MSG_TYPE
+from ascii_colors import ASCIIColors, trace_exception
+
+BindingName = "OpenRouterTTIBinding"
+
+class OpenRouterTTIBinding(LollmsTTIBinding):
+    def __init__(self, **kwargs):
+        # Prioritize 'model_name' but accept 'model' as an alias from config files.
+        if 'model' in kwargs and 'model_name' not in kwargs:
+            kwargs['model_name'] = kwargs.pop('model')
+            
+        # The manager passes binding_name in kwargs. To avoid "multiple values for keyword argument",
+        # we pop it and use the local BindingName constant or the passed value.
+        binding_name = kwargs.pop('binding_name', BindingName)
+        super().__init__(binding_name=binding_name, **kwargs)
+        
+        self.service_key = kwargs.get("service_key", "")
+        # Default to a known stable image-capable model
+        self.model_name = kwargs.get("model_name", "google/gemini-2.0-flash-exp:free")
+        self.host_address = "https://openrouter.ai/api/v1"
+        self.config = kwargs
+
+    def _get_aspect_ratio(self, width: int, height: int) -> str:
+        """Helper to map width/height to OpenRouter supported aspect ratios."""
+        ratio = width / height
+        if abs(ratio - 1.0) < 0.1: return "1:1"
+        if abs(ratio - 0.66) < 0.1: return "2:3"
+        if abs(ratio - 1.5) < 0.1: return "3:2"
+        if abs(ratio - 0.75) < 0.1: return "3:4"
+        if abs(ratio - 1.33) < 0.1: return "4:3"
+        if abs(ratio - 0.8) < 0.1: return "4:5"
+        if abs(ratio - 1.25) < 0.1: return "5:4"
+        if abs(ratio - 0.56) < 0.1: return "9:16"
+        if abs(ratio - 1.77) < 0.1: return "16:9"
+        if abs(ratio - 2.33) < 0.1: return "21:9"
+        return "1:1"
+
+    def generate_image(self, 
+                       prompt: str, 
+                       negative_prompt: str = "", 
+                       width: int = 1024, 
+                       height: int = 1024, 
+                       **kwargs) -> bytes:
+        """
+        Generates an image using Open Router's /chat/completions endpoint with modalities.
+        """
+        model = kwargs.get("model_name", self.model_name)
+        
+        headers = {
+            "Authorization": f"Bearer {self.service_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://github.com/ParisNeo/lollms_client",
+            "X-Title": "LoLLMS Client"
+        }
+        
+        # Open Router specific payload using Chat Completions
+        payload = {
+            "model": model,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": prompt if not negative_prompt else f"{prompt}\n\nNegative prompt: {negative_prompt}"
+                }
+            ],
+            "modalities": ["image", "text"],
+            "stream": False
+        }
+
+        # Add image configuration if relevant
+        image_config = {}
+        aspect_ratio = kwargs.get("aspect_ratio")
+        if not aspect_ratio:
+            aspect_ratio = self._get_aspect_ratio(width, height)
+        
+        image_config["aspect_ratio"] = aspect_ratio
+        
+        if "image_size" in kwargs:
+            image_config["image_size"] = kwargs["image_size"]
+        
+        payload["image_config"] = image_config
+
+        try:
+            ASCIIColors.info(f"Open Router TTI Request: Model={model}, Aspect Ratio={aspect_ratio}")
+            response = requests.post(
+                f"{self.host_address}/chat/completions", 
+                headers=headers, 
+                json=payload,
+                timeout=300
+            )
+            response.raise_for_status()
+            
+            result = response.json()
+            if result.get("choices"):
+                message = result["choices"][0].get("message", {})
+                images = message.get("images", [])
+                
+                if images:
+                    image_url = images[0]["image_url"]["url"]
+                    if image_url.startswith("data:image"):
+                        base64_str = image_url.split(",")[1]
+                        return base64.b64decode(base64_str)
+                    else:
+                        img_res = requests.get(image_url)
+                        img_res.raise_for_status()
+                        return img_res.content
+                    
+            raise ValueError(f"No image found in Open Router response: {result}")
+
+        except Exception as e:
+            ASCIIColors.error(f"Open Router TTI Error: {e}")
+            trace_exception(e)
+            return None
+
+    def list_models(self) -> List[Dict[str, Any]]:
+        """
+        Lists available models from Open Router and filters for TTI capabilities.
+        """
+        try:
+            response = requests.get(f"{self.host_address}/models")
+            response.raise_for_status()
+            models = response.json().get("data", [])
+            
+            filtered_models = []
+            # Curated list of keywords that identify Image Generation models on OpenRouter
+            tti_keywords = ["flux", "dall-e", "imagen", "stable-diffusion", "midjourney", "riverflow"]
+            
+            for m in models:
+                m_id = m.get("id", "").lower()
+                description = m.get("description", "").lower()
+                # OpenRouter sometimes provides output_modalities in the architecture block
+                modality = m.get("architecture", {}).get("modality", "text")
+                
+                # Check if it's explicitly an image model or matches TTI keywords
+                is_tti = "image" in modality or \
+                         any(kw in m_id for kw in tti_keywords) or \
+                         "generate images" in description or \
+                         "text-to-image" in description
+
+                if is_tti:
+                    filtered_models.append({
+                        "model_name": m.get("id"),
+                        "display_name": m.get("name"),
+                        "description": m.get("description", "Image generation model")
+                    })
+            
+            # Sort by name for easier navigation
+            filtered_models = sorted(filtered_models, key=lambda x: x["display_name"])
+
+            # Hardcoded fallbacks if API discovery fails or to ensure core models are present
+            if not filtered_models:
+                return [
+                    {"model_name": "google/gemini-3-pro-image-preview", "display_name": "Gemini 3.0 Pro image"},
+                    {"model_name": "black-forest-labs/flux.1-pro", "display_name": "FLUX.1 Pro"},
+                    {"model_name": "openai/gpt-5-image", "display_name": "gpt-5-image"}
+                ]
+                
+            return filtered_models
+        except Exception as e:
+            ASCIIColors.error(f"Failed to list Open Router models: {e}")
+            return []
+
+    def list_services(self, **kwargs) -> List[Dict[str, str]]:
+        return [{"name": "Open Router TTI", "id": "open_router"}]
+
+    def get_settings(self, **kwargs) -> Optional[Dict[str, Any]]:
+        return self.config
+
+    def set_settings(self, settings: Dict[str, Any], **kwargs) -> bool:
+        self.config.update(settings)
+        if "service_key" in settings:
+            self.service_key = settings["service_key"]
+        if "model_name" in settings:
+            self.model_name = settings["model_name"]
+        return True
+
+    def edit_image(self, images: Union[str, List[str], "Image.Image", List["Image.Image"]], prompt: str, **kwargs) -> bytes:
+
+        model = kwargs.get("model_name", self.model_name)
+        negative_prompt = kwargs.get("negative_prompt", "")
+        width = kwargs.get("width", 1024)
+        height = kwargs.get("height", 1024)
+        
+        headers = {
+            "Authorization": f"Bearer {self.service_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "https://github.com/ParisNeo/lollms_client",
+            "X-Title": "LoLLMS Client"
+        }
+        
+        # Convert images to base64 data URLs
+        if not isinstance(images, list):
+            images = [images]
+        
+        image_contents = []
+        for img in images:
+            if isinstance(img, str):
+                # Check if it's already a data URL
+                if img.startswith('data:image'):
+                    image_contents.append({
+                        "type": "image_url",
+                        "image_url": {"url": img}
+                    })
+                # Check if it's a regular URL
+                elif img.startswith(('http://', 'https://')):
+                    image_contents.append({
+                        "type": "image_url",
+                        "image_url": {"url": img}
+                    })
+                # Check if it's base64 data without the data URL prefix
+                elif len(img) > 100 and not '/' in img[:50] and not '\\' in img[:50]:
+                    # Assume it's raw base64 data
+                    image_contents.append({
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/png;base64,{img}"}
+                    })
+                else:
+                    # Assume it's a local file path
+                    try:
+                        with open(img, 'rb') as f:
+                            img_data = base64.b64encode(f.read()).decode('utf-8')
+                            image_contents.append({
+                                "type": "image_url",
+                                "image_url": {"url": f"data:image/jpeg;base64,{img_data}"}
+                            })
+                    except FileNotFoundError:
+                        ASCIIColors.warning(f"Could not find file: {img[:50]}... treating as base64 data")
+                        # If file not found, treat as base64
+                        image_contents.append({
+                            "type": "image_url",
+                            "image_url": {"url": f"data:image/png;base64,{img}"}
+                        })
+            else:
+                # PIL Image object
+                from io import BytesIO
+                buffer = BytesIO()
+                img.save(buffer, format='PNG')
+                img_data = base64.b64encode(buffer.getvalue()).decode('utf-8')
+                image_contents.append({
+                    "type": "image_url",
+                    "image_url": {"url": f"data:image/png;base64,{img_data}"}
+                })
+        
+        # Build message content with images and text
+        content = image_contents + [{
+            "type": "text",
+            "text": prompt if not negative_prompt else f"{prompt}\n\nNegative prompt: {negative_prompt}"
+        }]
+        
+        # Open Router specific payload using Chat Completions
+        payload = {
+            "model": model,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": content
+                }
+            ],
+            "modalities": ["image", "text"],
+            "stream": False
+        }
+
+        # Add image configuration if relevant
+        image_config = {}
+        aspect_ratio = kwargs.get("aspect_ratio")
+        if not aspect_ratio:
+            aspect_ratio = self._get_aspect_ratio(width, height)
+        
+        image_config["aspect_ratio"] = aspect_ratio
+        
+        if "image_size" in kwargs:
+            image_config["image_size"] = kwargs["image_size"]
+        
+        payload["image_config"] = image_config
+
+        try:
+            ASCIIColors.info(f"Open Router Image Edit Request: Model={model}, Aspect Ratio={aspect_ratio}, Images={len(images)}")
+            response = requests.post(
+                f"{self.host_address}/chat/completions", 
+                headers=headers, 
+                json=payload,
+                timeout=300
+            )
+            response.raise_for_status()
+            
+            result = response.json()
+            if result.get("choices"):
+                choice = result["choices"][0]
+                
+                # Check if there's an error in the choice
+                if "error" in choice:
+                    error_info = choice["error"]
+                    error_msg = error_info.get("message", "Unknown error")
+                    error_code = error_info.get("code", "unknown")
+                    raise ValueError(f"API Error ({error_code}): {error_msg}")
+                
+                message = choice.get("message", {})
+                
+                # Check if there are images in the response
+                response_images = message.get("images", [])
+                if response_images:
+                    image_url = response_images[0]["image_url"]["url"]
+                    if image_url.startswith("data:image"):
+                        base64_str = image_url.split(",")[1]
+                        return base64.b64decode(base64_str)
+                    else:
+                        img_res = requests.get(image_url)
+                        img_res.raise_for_status()
+                        return img_res.content
+                
+                # If no images, check if there's a text response (refusal or error)
+                content = message.get("content", "")
+                if content:
+                    raise ValueError(f"Model returned text instead of image: {content}")
+                    
+            raise ValueError(f"No image found in Open Router response: {result}")
+
+        except ValueError as ve:
+            # Re-raise ValueError with the message for user feedback
+            ASCIIColors.error(f"Open Router Image Edit Error: {ve}")
+            raise
+        except Exception as e:
+            ASCIIColors.error(f"Open Router Image Edit Error: {e}")
+            trace_exception(e)
+            return None
+        
+if __name__ == "__main__":
+    import os
+    key = os.getenv("OPENROUTER_API_KEY", "")
+    if not key:
+        print("Please set OPENROUTER_API_KEY env var.")
+    else:
+        binding = OpenRouterTTIBinding(service_key=key)
+        img = binding.generate_image("A cute robot painting a picture")
+        if img:
+            with open("output.png", "wb") as f: f.write(img)

{lollms_client-1.7.13.dist-info → lollms_client-1.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 1.7.13
+Version: 1.8.3
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License:                                  Apache License