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

lollms_client/llm_bindings/ollama/__init__.py

@@ -7,7 +7,7 @@ from lollms_client.lollms_types import MSG_TYPE
 # from lollms_client.lollms_utilities import encode_image 
 from lollms_client.lollms_types import ELF_COMPLETION_FORMAT
 from lollms_client.lollms_discussion import LollmsDiscussion
-from typing import Optional, Callable, List, Union, Dict
+from typing import Optional, Callable, List, Union, Dict, Any
 
 from ascii_colors import ASCIIColors, trace_exception
 import pipmaster as pm
@@ -718,6 +718,44 @@ class OllamaBinding(LollmsLLMBinding):
             trace_exception(ex)
             return {"status": False, "message": msg}
 
+    def get_zoo(self) -> List[Dict[str, Any]]:
+        """
+        Returns a list of models available for download.
+        each entry is a dict with:
+        name, description, size, type, link
+        """
+        return [
+            {"name": "Llama3 8B", "description": "Meta's Llama 3 8B model. Good for general purpose chat.", "size": "4.7GB", "type": "model", "link": "llama3"},
+            {"name": "Llama3 70B", "description": "Meta's Llama 3 70B model. High capability.", "size": "40GB", "type": "model", "link": "llama3:70b"},
+            {"name": "Phi-3 Mini", "description": "Microsoft's Phi-3 Mini 3.8B model. Lightweight and capable.", "size": "2.3GB", "type": "model", "link": "phi3"},
+            {"name": "Phi-3 Medium", "description": "Microsoft's Phi-3 Medium 14B model.", "size": "7.9GB", "type": "model", "link": "phi3:medium"},
+            {"name": "Mistral 7B", "description": "Mistral AI's 7B model v0.3.", "size": "4.1GB", "type": "model", "link": "mistral"},
+            {"name": "Mixtral 8x7B", "description": "Mistral AI's Mixture of Experts model.", "size": "26GB", "type": "model", "link": "mixtral"},
+            {"name": "Gemma 2 9B", "description": "Google's Gemma 2 9B model.", "size": "5.4GB", "type": "model", "link": "gemma2"},
+            {"name": "Gemma 2 27B", "description": "Google's Gemma 2 27B model.", "size": "16GB", "type": "model", "link": "gemma2:27b"},
+            {"name": "Qwen 2.5 7B", "description": "Alibaba Cloud's Qwen2.5 7B model.", "size": "4.5GB", "type": "model", "link": "qwen2.5"},
+            {"name": "Qwen 2.5 Coder 7B", "description": "Alibaba Cloud's Qwen2.5 Coder 7B model.", "size": "4.5GB", "type": "model", "link": "qwen2.5-coder"},
+            {"name": "CodeLlama 7B", "description": "Meta's CodeLlama 7B model.", "size": "3.8GB", "type": "model", "link": "codellama"},
+            {"name": "LLaVA 7B", "description": "Visual instruction tuning model (Vision).", "size": "4.5GB", "type": "model", "link": "llava"},
+            {"name": "Nomic Embed Text", "description": "A high-performing open embedding model.", "size": "274MB", "type": "embedding", "link": "nomic-embed-text"},
+            {"name": "DeepSeek Coder V2", "description": "DeepSeek Coder V2 model.", "size": "8.9GB", "type": "model", "link": "deepseek-coder-v2"},
+            {"name": "OpenHermes 2.5 Mistral", "description": "High quality finetune of Mistral 7B.", "size": "4.1GB", "type": "model", "link": "openhermes"},
+            {"name": "Dolphin Phi", "description": "Uncensored Dolphin fine-tune of Phi-2.", "size": "1.6GB", "type": "model", "link": "dolphin-phi"},
+            {"name": "TinyLlama", "description": "A compact 1.1B model.", "size": "637MB", "type": "model", "link": "tinyllama"},
+        ]
+
+    def download_from_zoo(self, index: int, progress_callback: Callable[[dict], None] = None) -> dict:
+        """
+        Downloads a model from the zoo using its index.
+        """
+        zoo = self.get_zoo()
+        if index < 0 or index >= len(zoo):
+            msg = "Index out of bounds"
+            ASCIIColors.error(msg)
+            return {"status": False, "message": msg}
+        item = zoo[index]
+        return self.pull_model(item["link"], progress_callback=progress_callback)
+
     def install_ollama(self, callback: Callable[[dict], None] = None, **kwargs) -> dict:
         """
         Installs Ollama based on the operating system.
@@ -1157,4 +1195,4 @@ if __name__ == '__main__':
         ASCIIColors.error(f"An error occurred during testing: {e}")
         trace_exception(e)
 
-    ASCIIColors.yellow("\nOllamaBinding test finished.")
+    ASCIIColors.yellow("\nOllamaBinding test finished.")

lollms_client/lollms_discussion.py

@@ -34,8 +34,7 @@ if False:
 
 from lollms_client.lollms_utilities import build_image_dicts, robust_json_parser
 from ascii_colors import ASCIIColors, trace_exception
-# Assuming lollms_types is a local module providing MSG_TYPE enum/constants
-# from .lollms_types import MSG_TYPE 
+from lollms_client.lollms_types import MSG_TYPE 
 
 class EncryptedString(TypeDecorator):
     """A SQLAlchemy TypeDecorator for field-level database encryption.
@@ -472,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()
     
@@ -963,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.
@@ -1054,7 +1202,7 @@ class LollmsDiscussion:
         debug: bool = False,
         remove_thinking_blocks:bool = True,
         **kwargs
-    ) -> Dict[str, 'LollmsMessage']:
+    ) -> Dict[str, Any]:
         """Main interaction method that can invoke the dynamic, multi-modal agent.
 
         This method orchestrates the entire response generation process. It can
@@ -1095,14 +1243,37 @@ class LollmsDiscussion:
             where the 'ai_message' will contain rich metadata if an agentic turn was used.
         """
         callback = kwargs.get("streaming_callback")
+        collected_sources = []
+        
+
+        # Step 1: Add user message, now including any images.
+        if add_user_message:
+            user_msg = self.add_message(
+                sender=kwargs.get("user_name", "user"), 
+                sender_type="user", 
+                content=user_message,
+                images=images,
+                **kwargs
+            )
+        else: # Regeneration logic
+            # _validate_and_set_active_branch ensures active_branch_id is valid and a leaf.
+            # So, if we are regenerating, active_branch_id must be valid.
+            if self.active_branch_id not in self._message_index: # Redundant check, but safe
+                 raise ValueError("Regeneration failed: active branch tip not found or is invalid.")
+            user_msg_orm = self._message_index[self.active_branch_id]
+            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)
+            # 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:
             object.__setattr__(self, '_system_prompt', personality.system_prompt)
 
             # --- New Data Source Handling Logic ---
             if hasattr(personality, 'data_source') and personality.data_source is not None:
-                # Placeholder for MSG_TYPE if not imported
-                MSG_TYPE = SimpleNamespace(MSG_TYPE_STEP="step", MSG_TYPE_STEP_START="step_start", MSG_TYPE_STEP_END="step_end", MSG_TYPE_EXCEPTION="exception")
 
                 if isinstance(personality.data_source, str):
                     # --- Static Data Source ---
@@ -1154,6 +1325,15 @@ class LollmsDiscussion:
                                 
                                 if retrieved_data:
                                     self.personality_data_zone = retrieved_data.strip()
+                                    source_item = {
+                                        "title": "Personality Data Source",
+                                        "content": retrieved_data,
+                                        "source": personality.name if hasattr(personality, 'name') else "Personality",
+                                        "query": generated_query
+                                    }
+                                    collected_sources.append(source_item)
+                                    if callback:
+                                        callback([source_item], MSG_TYPE.MSG_TYPE_SOURCES_LIST)
 
                             except Exception as e:
                                 trace_exception(e)
@@ -1175,26 +1355,6 @@ class LollmsDiscussion:
         if self.max_context_size is not None:
             self.summarize_and_prune(self.max_context_size)
 
-        # Step 1: Add user message, now including any images.
-        if add_user_message:
-            user_msg = self.add_message(
-                sender=kwargs.get("user_name", "user"), 
-                sender_type="user", 
-                content=user_message,
-                images=images,
-                **kwargs
-            )
-        else: # Regeneration logic
-            # _validate_and_set_active_branch ensures active_branch_id is valid and a leaf.
-            # So, if we are regenerating, active_branch_id must be valid.
-            if self.active_branch_id not in self._message_index: # Redundant check, but safe
-                 raise ValueError("Regeneration failed: active branch tip not found or is invalid.")
-            user_msg_orm = self._message_index[self.active_branch_id]
-            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
-
         is_agentic_turn = (effective_use_mcps is not None and effective_use_mcps) or (use_data_store is not None and use_data_store)
         
         start_time = datetime.now()
@@ -1240,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")
@@ -1262,9 +1422,12 @@ class LollmsDiscussion:
         message_meta = {}
         if is_agentic_turn and isinstance(agent_result, dict):
             if "tool_calls" in agent_result: message_meta["tool_calls"] = agent_result["tool_calls"]
-            if "sources" in agent_result: message_meta["sources"] = agent_result["sources"]
+            if "sources" in agent_result: collected_sources.extend(agent_result["sources"])
             if agent_result.get("clarification_required", False): message_meta["clarification_required"] = True
 
+        if collected_sources:
+             message_meta["sources"] = collected_sources
+
         ai_message_obj = self.add_message(
             sender=personality.name if personality else "assistant",
             sender_type="assistant",
@@ -1282,15 +1445,13 @@ class LollmsDiscussion:
         if self._is_db_backed and self.autosave:
             self.commit()
             
-        return {"user_message": user_msg, "ai_message": ai_message_obj}
+        return {"user_message": user_msg, "ai_message": ai_message_obj, "sources": collected_sources}
 
-    def regenerate_branch(self, branch_tip_id: Optional[str] = None, **kwargs) -> Dict[str, 'LollmsMessage']:
+    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.
@@ -1321,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_llm_binding.py

@@ -2,7 +2,7 @@
 from abc import abstractmethod
 import importlib
 from pathlib import Path
-from typing import Optional, Callable, List, Union, Dict
+from typing import Optional, Callable, List, Union, Dict, Any
 from ascii_colors import trace_exception, ASCIIColors
 from lollms_client.lollms_types import MSG_TYPE
 from lollms_client.lollms_discussion import LollmsDiscussion
@@ -212,6 +212,20 @@ class LollmsLLMBinding(LollmsBaseBinding):
         """
         pass
 
+    def get_zoo(self) -> List[Dict[str, Any]]:
+        """
+        Returns a list of models available for download.
+        each entry is a dict with:
+        name, description, size, type, link
+        """
+        return []
+
+    def download_from_zoo(self, index: int, progress_callback: Callable[[dict], None] = None) -> dict:
+        """
+        Downloads a model from the zoo using its index.
+        """
+        return {"status": False, "message": "Not implemented"}
+
     @abstractmethod
     def load_model(self, model_name: str) -> bool:
         """

lollms_client/lollms_mcp_binding.py

@@ -2,7 +2,7 @@
 from abc import abstractmethod
 import importlib
 from pathlib import Path
-from typing import Optional, List, Dict, Any, Union
+from typing import Optional, List, Dict, Any, Union, Callable
 from ascii_colors import trace_exception, ASCIIColors
 import yaml
 from lollms_client.lollms_base_binding import LollmsBaseBinding
@@ -52,6 +52,20 @@ class LollmsMCPBinding(LollmsBaseBinding):
         Or could be implemented to return available tools as models if desired.
         """
         return []
+    
+    def get_zoo(self) -> List[Dict[str, Any]]:
+        """
+        Returns a list of models available for download.
+        each entry is a dict with:
+        name, description, size, type, link
+        """
+        return []
+
+    def download_from_zoo(self, index: int, progress_callback: Callable[[dict], None] = None) -> dict:
+        """
+        Downloads a model from the zoo using its index.
+        """
+        return {"status": False, "message": "Not implemented"}
 
 class LollmsMCPBindingManager:
     """
@@ -67,7 +81,6 @@ class LollmsMCPBindingManager:
             self.mcp_bindings_dir = (Path(__file__).parent.parent / mcp_bindings_dir).resolve()
 
         self.available_bindings: Dict[str, type[LollmsMCPBinding]] = {}
-        ASCIIColors.info(f"LollmsMCPBindingManager initialized. Bindings directory: {self.mcp_bindings_dir}")
 
 
     def _load_binding_class(self, binding_name: str) -> Optional[type[LollmsMCPBinding]]:
@@ -127,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

@@ -2,7 +2,7 @@
 from abc import abstractmethod
 import importlib
 from pathlib import Path
-from typing import Optional, List, Dict, Any, Union
+from typing import Optional, List, Dict, Any, Union, Callable
 from ascii_colors import trace_exception
 import yaml
 from lollms_client.lollms_base_binding import LollmsBaseBinding
@@ -32,6 +32,20 @@ class LollmsSTTBinding(LollmsBaseBinding):
         """
         pass
 
+    def get_zoo(self) -> List[Dict[str, Any]]:
+        """
+        Returns a list of models available for download.
+        each entry is a dict with:
+        name, description, size, type, link
+        """
+        return []
+
+    def download_from_zoo(self, index: int, progress_callback: Callable[[dict], None] = None) -> dict:
+        """
+        Downloads a model from the zoo using its index.
+        """
+        return {"status": False, "message": "Not implemented"}
+
 class LollmsSTTBindingManager:
     """Manages STT binding discovery and instantiation."""
 
@@ -74,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

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 import importlib
 from pathlib import Path
-from typing import Optional, List, Dict, Any, Union
+from typing import Optional, List, Dict, Any, Union, Callable
 from ascii_colors import trace_exception
 import yaml
 from lollms_client.lollms_base_binding import LollmsBaseBinding
@@ -57,6 +57,20 @@ class LollmsTTIBinding(LollmsBaseBinding):
     def list_models(self) -> list:
         """Lists models"""
         pass
+    
+    def get_zoo(self) -> List[Dict[str, Any]]:
+        """
+        Returns a list of models available for download.
+        each entry is a dict with:
+        name, description, size, type, link
+        """
+        return []
+
+    def download_from_zoo(self, index: int, progress_callback: Callable[[dict], None] = None) -> dict:
+        """
+        Downloads a model from the zoo using its index.
+        """
+        return {"status": False, "message": "Not implemented"}
 
     @abstractmethod
     def set_settings(self, settings: Dict[str, Any], **kwargs) -> bool:
@@ -91,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

@@ -2,7 +2,7 @@
 from abc import abstractmethod
 import importlib
 from pathlib import Path
-from typing import Optional, List, Dict, Any, Union
+from typing import Optional, List, Dict, Any, Union, Callable
 from ascii_colors import trace_exception
 from lollms_client.lollms_base_binding import LollmsBaseBinding
 
@@ -32,6 +32,20 @@ class LollmsTTMBinding(LollmsBaseBinding):
         """
         pass
 
+    def get_zoo(self) -> List[Dict[str, Any]]:
+        """
+        Returns a list of models available for download.
+        each entry is a dict with:
+        name, description, size, type, link
+        """
+        return []
+
+    def download_from_zoo(self, index: int, progress_callback: Callable[[dict], None] = None) -> dict:
+        """
+        Downloads a model from the zoo using its index.
+        """
+        return {"status": False, "message": "Not implemented"}
+
 class LollmsTTMBindingManager:
     """Manages TTM binding discovery and instantiation."""
 
@@ -63,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

@@ -1,7 +1,7 @@
 from abc import abstractmethod
 import importlib
 from pathlib import Path
-from typing import Optional, List, Dict, Any, Union
+from typing import Optional, List, Dict, Any, Union, Callable
 import yaml
 from ascii_colors import trace_exception
 from lollms_client.lollms_base_binding import LollmsBaseBinding
@@ -27,7 +27,21 @@ class LollmsTTSBinding(LollmsBaseBinding):
     @abstractmethod
     def list_models(self, **kwargs) -> List[str]:
         pass
+
+    def get_zoo(self) -> List[Dict[str, Any]]:
+        """
+        Returns a list of models available for download.
+        each entry is a dict with:
+        name, description, size, type, link
+        """
+        return []
         
+    def download_from_zoo(self, index: int, progress_callback: Callable[[dict], None] = None) -> dict:
+        """
+        Downloads a model from the zoo using its index.
+        """
+        return {"status": False, "message": "Not implemented"}
+
     def get_settings(self, **kwargs) -> Dict[str, Any]:
         return self.settings
 
@@ -61,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