lollms-client 0.26.0__tar.gz → 0.27.0__tar.gz

{lollms_client-0.26.0 → lollms_client-0.27.0}/PKG-INFO

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

{lollms_client-0.26.0 → lollms_client-0.27.0}/lollms_client/__init__.py

@@ -6,9 +6,9 @@ from lollms_client.lollms_personality import LollmsPersonality
 from lollms_client.lollms_utilities import PromptReshaper # Keep general utilities
 # Import new MCP binding classes
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
+from lollms_client.lollms_llm_binding import LollmsLLMBindingManager
 
-
-__version__ = "0.26.0" # Updated version
+__version__ = "0.27.0" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [
@@ -21,5 +21,6 @@ __all__ = [
     "LollmsDataManager",
     "PromptReshaper",
     "LollmsMCPBinding", # Export LollmsMCPBinding ABC
+    "LollmsLLMBindingManager",
     "LollmsMCPBindingManager", # Export LollmsMCPBindingManager
 ]

{lollms_client-0.26.0 → lollms_client-0.27.0}/lollms_client/llm_bindings/claude/__init__.py

@@ -329,7 +329,7 @@ class ClaudeBinding(LollmsLLMBinding):
             # Note: count_tokens doesn't use a system prompt, so it's safe.
             # However, for consistency, we could add one if needed by the logic.
             # For now, this is fine as it only counts user content tokens.
-            response = self.client.count_tokens( # Changed from messages.count_tokens to top-level client method
+            response = self.client.messages.count_tokens( # Changed from messages.count_tokens to top-level client method
                 model=self.model_name,
                 messages=[{"role": "user", "content": text}]
             )

lollms_client-0.27.0/lollms_client/llm_bindings/grok/__init__.py

@@ -0,0 +1,536 @@
+import base64
+import os
+import json
+import requests
+from io import BytesIO
+from pathlib import Path
+from typing import Optional, Callable, List, Union, Dict
+
+from lollms_client.lollms_discussion import LollmsDiscussion, LollmsMessage
+from lollms_client.lollms_llm_binding import LollmsLLMBinding
+from lollms_client.lollms_types import MSG_TYPE
+from ascii_colors import ASCIIColors, trace_exception
+
+import pipmaster as pm
+
+# Ensure the required packages are installed
+pm.ensure_packages(["requests", "pillow", "tiktoken"])
+
+from PIL import Image, ImageDraw
+import tiktoken
+
+BindingName = "GrokBinding"
+
+# API Endpoint
+GROK_API_BASE_URL = "https://api.x.ai/v1"
+
+# A hardcoded list to be used as a fallback if the API call fails
+_FALLBACK_MODELS = [
+    {'model_name': 'grok-1', 'display_name': 'Grok 1', 'description': 'The flagship conversational model from xAI.', 'owned_by': 'xAI'},
+    {'model_name': 'grok-1.5', 'display_name': 'Grok 1.5', 'description': 'The latest multimodal model from xAI.', 'owned_by': 'xAI'},
+    {'model_name': 'grok-1.5-vision-preview', 'display_name': 'Grok 1.5 Vision (Preview)', 'description': 'Multimodal model with vision capabilities (preview).', 'owned_by': 'xAI'},
+]
+
+# Helper to check if a string is a valid path to an image
+def is_image_path(path_str: str) -> bool:
+    try:
+        p = Path(path_str)
+        return p.is_file() and p.suffix.lower() in ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp']
+    except Exception:
+        return False
+
+# Helper to get image media type for base64 URI
+def get_media_type_for_uri(image_path: Union[str, Path]) -> str:
+    path = Path(image_path)
+    ext = path.suffix.lower()
+    if ext == ".jpg" or ext == ".jpeg":
+        return "image/jpeg"
+    elif ext == ".png":
+        return "image/png"
+    elif ext == ".gif":
+        return "image/gif"
+    elif ext == ".webp":
+        return "image/webp"
+    else:
+        # Default to PNG as it's lossless and widely supported
+        return "image/png"
+
+
+class GrokBinding(LollmsLLMBinding):
+    """xAI Grok-specific binding implementation."""
+
+    def __init__(self,
+                 host_address: str = None,  # Ignored, for compatibility
+                 model_name: str = "grok-1.5-vision-preview",
+                 service_key: str = None,
+                 verify_ssl_certificate: bool = True, # Ignored, for compatibility
+                 **kwargs
+                 ):
+        """
+        Initialize the Grok binding.
+
+        Args:
+            model_name (str): Name of the Grok model to use.
+            service_key (str): xAI API key.
+        """
+        super().__init__(binding_name=BindingName)
+        self.model_name = model_name
+        self.service_key = service_key
+        self.base_url = kwargs.get("base_url", GROK_API_BASE_URL)
+        self._cached_models: Optional[List[Dict[str, str]]] = None
+
+        if not self.service_key:
+            self.service_key = os.getenv("XAI_API_KEY")
+        
+        if not self.service_key:
+            raise ValueError("xAI API key is required. Please set it via the 'service_key' parameter or the XAI_API_KEY environment variable.")
+
+        self.headers = {
+            "Authorization": f"Bearer {self.service_key}",
+            "Content-Type": "application/json"
+        }
+
+    def _construct_parameters(self,
+                              temperature: float,
+                              top_p: float,
+                              n_predict: int) -> Dict[str, any]:
+        """Builds a parameters dictionary for the Grok API."""
+        params = {"stream": True} # Always stream from the API
+        if temperature is not None: params['temperature'] = float(temperature)
+        if top_p is not None: params['top_p'] = top_p
+        # Grok has a model-specific max_tokens, but we can request less.
+        if n_predict is not None: params['max_tokens'] = n_predict
+        return params
+
+    def _process_and_handle_stream(self,
+                                  response: requests.Response,
+                                  stream: bool,
+                                  streaming_callback: Optional[Callable[[str, MSG_TYPE], None]]
+                                  ) -> Union[str, dict]:
+        """Helper to process streaming responses from the API."""
+        full_response_text = ""
+        
+        try:
+            for line in response.iter_lines():
+                if line:
+                    decoded_line = line.decode('utf-8')
+                    if decoded_line.startswith('data: '):
+                        json_str = decoded_line[len('data: '):]
+                        if json_str.strip() == "[DONE]":
+                            break
+                        try:
+                            chunk = json.loads(json_str)
+                            if chunk['choices']:
+                                delta = chunk['choices'][0].get('delta', {})
+                                content = delta.get('content', '')
+                                if content:
+                                    full_response_text += content
+                                    if stream and streaming_callback:
+                                        if not streaming_callback(content, MSG_TYPE.MSG_TYPE_CHUNK):
+                                            # Stop streaming if the callback returns False
+                                            return full_response_text
+                        except json.JSONDecodeError:
+                            ASCIIColors.warning(f"Could not decode JSON chunk: {json_str}")
+                            continue
+
+            # This handles both cases:
+            # - If stream=True, we have already sent chunks. We return the full string.
+            # - If stream=False, we have buffered the whole response and now return it.
+            return full_response_text
+        
+        except Exception as ex:
+            error_message = f"An unexpected error occurred while processing the Grok stream: {str(ex)}"
+            trace_exception(ex)
+            return {"status": False, "error": error_message}
+
+
+    def generate_text(self,
+                     prompt: str,
+                     images: Optional[List[str]] = None,
+                     system_prompt: str = "",
+                     n_predict: Optional[int] = 2048,
+                     stream: Optional[bool] = False,
+                     temperature: float = 0.7,
+                     top_p: float = 0.9,
+                     repeat_penalty: float = 1.1, # Not supported
+                     repeat_last_n: int = 64,   # Not supported
+                     seed: Optional[int] = None,      # Not supported
+                     n_threads: Optional[int] = None, # Not applicable
+                     ctx_size: int | None = None,     # Determined by model
+                     streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+                     **kwargs
+                     ) -> Union[str, dict]:
+        """
+        Generate text using the Grok model.
+        """
+        if not self.service_key:
+            return {"status": False, "error": "xAI API key not configured."}
+
+        api_params = self._construct_parameters(temperature, top_p, n_predict)
+
+        messages = []
+        if system_prompt and system_prompt.strip():
+            messages.append({"role": "system", "content": system_prompt})
+            
+        user_content = []
+        if prompt and prompt.strip():
+            user_content.append({"type": "text", "text": prompt})
+
+        if images:
+            for image_data in images:
+                try:
+                    if is_image_path(image_data):
+                        media_type = get_media_type_for_uri(image_data)
+                        with open(image_data, "rb") as image_file:
+                            b64_data = base64.b64encode(image_file.read()).decode('utf-8')
+                    else: # Assume it's a base64 string
+                        b64_data = image_data
+                        media_type = "image/png" # Assume PNG if raw base64
+
+                    user_content.append({
+                        "type": "image_url",
+                        "image_url": {"url": f"data:{media_type};base64,{b64_data}"}
+                    })
+                except Exception as e:
+                    error_msg = f"Failed to process image: {e}"
+                    ASCIIColors.error(error_msg)
+                    return {"status": False, "error": error_msg}
+
+        if not user_content:
+            if stream and streaming_callback:
+                streaming_callback("", MSG_TYPE.MSG_TYPE_FINISHED_MESSAGE)
+            return ""
+
+        messages.append({"role": "user", "content": user_content})
+
+        payload = {
+            "model": self.model_name,
+            "messages": messages,
+            **api_params
+        }
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=self.headers,
+                json=payload,
+                stream=True  # We always use the streaming endpoint
+            )
+            response.raise_for_status()
+            
+            return self._process_and_handle_stream(response, stream, streaming_callback)
+
+        except requests.exceptions.RequestException as ex:
+            error_message = f"Grok API request failed: {str(ex)}"
+            try: # Try to get more info from the response body
+                 error_message += f"\nResponse: {ex.response.text}"
+            except:
+                pass
+            trace_exception(ex)
+            return {"status": False, "error": error_message}
+        except Exception as ex:
+            error_message = f"An unexpected error occurred with Grok API: {str(ex)}"
+            trace_exception(ex)
+            return {"status": False, "error": error_message}
+
+
+    def chat(self,
+             discussion: LollmsDiscussion,
+             branch_tip_id: Optional[str] = None,
+             n_predict: Optional[int] = 2048,
+             stream: Optional[bool] = False,
+             temperature: float = 0.7,
+             top_p: float = 0.9,
+             streaming_callback: Optional[Callable[[str, MSG_TYPE], None]] = None,
+             **kwargs
+             ) -> Union[str, dict]:
+        """
+        Conduct a chat session with the Grok model using a LollmsDiscussion object.
+        """
+        if not self.service_key:
+             return {"status": "error", "message": "xAI API key not configured."}
+
+        system_prompt = discussion.system_prompt
+        discussion_messages = discussion.get_messages(branch_tip_id)
+        
+        messages = []
+        if system_prompt and system_prompt.strip():
+            messages.append({"role": "system", "content": system_prompt})
+            
+        for msg in discussion_messages:
+            role = 'assistant' if msg.sender_type == "assistant" else 'user'
+            
+            content_parts = []
+            if msg.content and msg.content.strip():
+                content_parts.append({"type": "text", "text": msg.content})
+            
+            if msg.images:
+                for file_path in msg.images:
+                    if is_image_path(file_path):
+                        try:
+                            media_type = get_media_type_for_uri(file_path)
+                            with open(file_path, "rb") as image_file:
+                                b64_data = base64.b64encode(image_file.read()).decode('utf-8')
+                            content_parts.append({
+                                "type": "image_url",
+                                "image_url": {"url": f"data:{media_type};base64,{b64_data}"}
+                            })
+                        except Exception as e:
+                            ASCIIColors.warning(f"Could not load image {file_path}: {e}")
+            
+            # Grok API expects content to be a string for assistant, or list for user.
+            if role == 'user':
+                messages.append({'role': role, 'content': content_parts})
+            else: # assistant
+                # Assistants can't send images, so we just extract the text.
+                text_content = next((part['text'] for part in content_parts if part['type'] == 'text'), "")
+                if text_content:
+                    messages.append({'role': role, 'content': text_content})
+        
+        if not messages or messages[-1]['role'] != 'user':
+            return {"status": "error", "message": "Cannot start chat without a user message."}
+
+        api_params = self._construct_parameters(temperature, top_p, n_predict)
+        
+        payload = {
+            "model": self.model_name,
+            "messages": messages,
+            **api_params
+        }
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/chat/completions",
+                headers=self.headers,
+                json=payload,
+                stream=True
+            )
+            response.raise_for_status()
+            
+            return self._process_and_handle_stream(response, stream, streaming_callback)
+
+        except requests.exceptions.RequestException as ex:
+            error_message = f"Grok API request failed: {str(ex)}"
+            try:
+                 error_message += f"\nResponse: {ex.response.text}"
+            except:
+                pass
+            trace_exception(ex)
+            return {"status": "error", "message": error_message}
+        except Exception as ex:
+            error_message = f"An unexpected error occurred with Grok API: {str(ex)}"
+            trace_exception(ex)
+            return {"status": "error", "message": error_message}
+            
+    def tokenize(self, text: str) -> list:
+        """
+        Tokenize the input text.
+        Note: Grok doesn't expose a public tokenizer API.
+        Using tiktoken's cl100k_base for a reasonable estimate.
+        """
+        try:
+            encoding = tiktoken.get_encoding("cl100k_base")
+            return encoding.encode(text)
+        except:
+            return list(text.encode('utf-8'))
+
+    def detokenize(self, tokens: list) -> str:
+        """
+        Detokenize a list of tokens.
+        Note: Based on the placeholder tokenizer.
+        """
+        try:
+            encoding = tiktoken.get_encoding("cl100k_base")
+            return encoding.decode(tokens)
+        except:
+            return bytes(tokens).decode('utf-8', errors='ignore')
+
+    def count_tokens(self, text: str) -> int:
+        """
+        Count tokens from a text using the fallback tokenizer.
+        """
+        return len(self.tokenize(text))
+
+    def embed(self, text: str, **kwargs) -> List[float]:
+        """
+        Get embeddings for the input text.
+        Note: xAI does not provide a dedicated embedding model API.
+        """
+        ASCIIColors.warning("xAI does not offer a public embedding API. This method is not implemented.")
+        raise NotImplementedError("Grok binding does not support embeddings.")
+
+    def get_model_info(self) -> dict:
+        """Return information about the current Grok model setup."""
+        return {
+            "name": self.binding_name,
+            "host_address": self.base_url,
+            "model_name": self.model_name,
+            "supports_structured_output": False,
+            "supports_vision": "vision" in self.model_name or "grok-1.5" == self.model_name,
+        }
+
+    def listModels(self) -> List[Dict[str, str]]:
+        """
+        Lists available models from the xAI API.
+        Caches the result to avoid repeated API calls.
+        Falls back to a static list if the API call fails.
+        """
+        if self._cached_models is not None:
+            return self._cached_models
+
+        if not self.service_key:
+            ASCIIColors.warning("Cannot fetch models without an API key. Using fallback list.")
+            self._cached_models = _FALLBACK_MODELS
+            return self._cached_models
+
+        try:
+            ASCIIColors.info("Fetching available models from xAI API...")
+            response = requests.get(f"{self.base_url}/models", headers=self.headers, timeout=15)
+            response.raise_for_status()
+            
+            data = response.json()
+            
+            if "data" in data and isinstance(data["data"], list):
+                models_data = data["data"]
+                formatted_models = []
+                for model in models_data:
+                    model_id = model.get("id")
+                    if not model_id: continue
+                    
+                    display_name = model_id.replace("-", " ").title()
+                    description = f"Context: {model.get('context_window', 'N/A')} tokens."
+                    
+                    formatted_models.append({
+                        'model_name': model_id,
+                        'display_name': display_name,
+                        'description': description,
+                        'owned_by': model.get('owned_by', 'xAI')
+                    })
+
+                self._cached_models = formatted_models
+                ASCIIColors.green(f"Successfully fetched {len(self._cached_models)} models.")
+                return self._cached_models
+            else:
+                raise ValueError("API response is malformed.")
+
+        except Exception as e:
+            ASCIIColors.error(f"Failed to fetch models from xAI API: {e}")
+            ASCIIColors.warning("Using hardcoded fallback list of models.")
+            trace_exception(e)
+            self._cached_models = _FALLBACK_MODELS
+            return self._cached_models
+
+    def load_model(self, model_name: str) -> bool:
+        """Set the model name for subsequent operations."""
+        self.model_name = model_name
+        ASCIIColors.info(f"Grok model set to: {model_name}. It will be used on the next API call.")
+        return True
+
+
+if __name__ == '__main__':
+    # Example Usage (requires XAI_API_KEY environment variable)
+    if 'XAI_API_KEY' not in os.environ:
+        ASCIIColors.red("Error: XAI_API_KEY environment variable not set.")
+        print("Please get your key from xAI and set it as an environment variable.")
+        exit(1)
+
+    ASCIIColors.yellow("--- Testing GrokBinding ---")
+
+    # --- Configuration ---
+    test_model_name = "grok-1"
+    test_vision_model_name = "grok-1.5-vision-preview"
+
+    try:
+        # --- Initialization ---
+        ASCIIColors.cyan("\n--- Initializing Binding ---")
+        binding = GrokBinding(model_name=test_model_name)
+        ASCIIColors.green("Binding initialized successfully.")
+
+        # --- List Models ---
+        ASCIIColors.cyan("\n--- Listing Models (dynamic) ---")
+        models = binding.listModels()
+        if models:
+            ASCIIColors.green(f"Found {len(models)} models.")
+            for m in models:
+                print(f"- {m['model_name']} ({m['display_name']})")
+        else:
+            ASCIIColors.error("Failed to list models.")
+
+        # --- Count Tokens ---
+        ASCIIColors.cyan("\n--- Counting Tokens ---")
+        sample_text = "Hello, world! This is a test from the Grok binding."
+        token_count = binding.count_tokens(sample_text)
+        ASCIIColors.green(f"Token count for '{sample_text}': {token_count} (using tiktoken)")
+
+        # --- Text Generation (Non-Streaming) ---
+        ASCIIColors.cyan("\n--- Text Generation (Non-Streaming) ---")
+        prompt_text = "Explain who Elon Musk is in one sentence."
+        ASCIIColors.info(f"Prompt: {prompt_text}")
+        generated_text = binding.generate_text(prompt_text, n_predict=100, stream=False, system_prompt="Be very concise.")
+        if isinstance(generated_text, str):
+            ASCIIColors.green(f"Generated text:\n{generated_text}")
+        else:
+            ASCIIColors.error(f"Generation failed: {generated_text}")
+
+        # --- Text Generation (Streaming) ---
+        ASCIIColors.cyan("\n--- Text Generation (Streaming) ---")
+        
+        full_streamed_text = ""
+        def stream_callback(chunk: str, msg_type: int):
+            ASCIIColors.green(chunk, end="", flush=True)
+            full_streamed_text += chunk
+            return True
+        
+        ASCIIColors.info(f"Prompt: {prompt_text}")
+        result = binding.generate_text(prompt_text, n_predict=150, stream=True, streaming_callback=stream_callback)
+        print("\n--- End of Stream ---")
+        ASCIIColors.green(f"Full streamed text (for verification): {result}")
+        assert result == full_streamed_text
+
+        # --- Embeddings ---
+        ASCIIColors.cyan("\n--- Embeddings ---")
+        try:
+            binding.embed("This should fail.")
+        except NotImplementedError as e:
+            ASCIIColors.green(f"Successfully caught expected error for embeddings: {e}")
+
+        # --- Vision Model Test ---
+        dummy_image_path = "grok_dummy_test_image.png"
+        try:
+            available_model_names = [m['model_name'] for m in models]
+            if test_vision_model_name not in available_model_names:
+                 ASCIIColors.warning(f"Vision test model '{test_vision_model_name}' not available. Skipping vision test.")
+            else:
+                img = Image.new('RGB', (250, 60), color=('red'))
+                d = ImageDraw.Draw(img)
+                d.text((10, 10), "This is a test image for Grok", fill=('white'))
+                img.save(dummy_image_path)
+                ASCIIColors.info(f"Created dummy image: {dummy_image_path}")
+
+                ASCIIColors.cyan(f"\n--- Vision Generation (using {test_vision_model_name}) ---")
+                binding.load_model(test_vision_model_name)
+                vision_prompt = "Describe this image. What does the text say?"
+                ASCIIColors.info(f"Vision Prompt: {vision_prompt} with image {dummy_image_path}")
+                
+                vision_response = binding.generate_text(
+                    prompt=vision_prompt,
+                    images=[dummy_image_path],
+                    n_predict=100,
+                    stream=False
+                )
+                if isinstance(vision_response, str):
+                    ASCIIColors.green(f"Vision model response: {vision_response}")
+                else:
+                    ASCIIColors.error(f"Vision generation failed: {vision_response}")
+        except Exception as e:
+            ASCIIColors.error(f"Error during vision test: {e}")
+            trace_exception(e)
+        finally:
+            if os.path.exists(dummy_image_path):
+                os.remove(dummy_image_path)
+
+    except Exception as e:
+        ASCIIColors.error(f"An error occurred during testing: {e}")
+        trace_exception(e)
+
+    ASCIIColors.yellow("\nGrokBinding test finished.")

{lollms_client-0.26.0 → lollms_client-0.27.0}/lollms_client/lollms_core.py

@@ -879,7 +879,7 @@ Don't forget encapsulate the code inside a html code tag. This is mandatory.
             
             formatted_agent_history = "No actions taken yet in this turn."
             if agent_work_history:
-                history_parts = [ f"### Step {i+1}:\n**Thought:** {entry['thought']}\n**Action:** Called tool `{entry['tool_name']}` with parameters `{json.dumps(entry['tool_params'])}`\n**Observation (Tool Output):**\n```json\n{json.dumps(entry['tool_result'], indent=2)}\n```" for i, entry in enumerate(agent_work_history)]
+                history_parts = [ f"### Step {i+1}:\n**Thought:**\n{entry['thought']}\n**Action:** Called tool `{entry['tool_name']}` with parameters `{json.dumps(entry['tool_params'])}`\n**Observation (Tool Output):**\n```json\n{json.dumps(entry['tool_result'], indent=2)}\n```" for i, entry in enumerate(agent_work_history)]
                 formatted_agent_history = "\n\n".join(history_parts)
 
             llm_decision = None
@@ -1580,8 +1580,8 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
         
         # Add the new put_code_in_buffer tool definition
         available_tools.append({
-            "name": "generate_code",
-            "description": """Generates and stores code into a buffer to be used by another tool. You can put the uuid of the generated code into the fields that require long code among the tools. If no tool requires code as input do not use generate_code. generate_code do not execute the code nor does it audit it.""",
+            "name": "put_code_in_buffer",
+            "description": """Generates and stores code into a buffer to be used by another tool. You can put the uuid of the generated code into the fields that require long code among the tools. If no tool requires code as input do not use put_code_in_buffer. put_code_in_buffer do not execute the code nor does it audit it.""",
             "input_schema": {"type": "object", "properties": {"prompt": {"type": "string", "description": "A detailed natural language description of the code's purpose and requirements."}, "language": {"type": "string", "description": "The programming language of the generated code. By default it uses python."}}, "required": ["prompt"]}
         })
         # Add the new refactor_scratchpad tool definition
@@ -1658,7 +1658,7 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                     
 
                 current_scratchpad += f"\n\n### Step {i+1}: Thought\n{thought}"
-                log_event(f"**Thought**: {thought}", MSG_TYPE.MSG_TYPE_THOUGHT_CONTENT)
+                log_event(f"**Thought**:\n{thought}", MSG_TYPE.MSG_TYPE_THOUGHT_CONTENT)
 
                 if not tool_name:
                     # Handle error...
@@ -1918,6 +1918,97 @@ Do not split the code in multiple tags.
 
         return code_content # Return the (potentially completed) code content or None
 
+    def generate_structured_content(
+        self,
+        prompt,
+        output_format,
+        extra_system_prompt=None,
+        **kwargs
+    ):
+        """
+        Generates structured data (a dict) from a prompt using a JSON template.
+
+        This method is a high-level wrapper around `generate_code`, specializing it 
+        for JSON output. It ensures the LLM sticks to a predefined structure,
+        and then parses the output into a Python dictionary.
+
+        Args:
+            prompt (str): 
+                The user's request (e.g., "Extract the name, age, and city of the person described").
+            output_format (dict or str): 
+                A Python dictionary or a JSON string representing the desired output 
+                structure. This will be used as a template for the LLM.
+                Example: {"name": "string", "age": "integer", "city": "string"}
+            extra_system_prompt (str, optional): 
+                Additional instructions for the system prompt, to be appended to the 
+                main instructions. Defaults to None.
+            **kwargs: 
+                Additional keyword arguments to be passed directly to the 
+                `generate_code` method (e.g., temperature, max_size, top_k, debug).
+
+        Returns:
+            dict: The parsed JSON data as a Python dictionary, or None if
+                generation or parsing fails.
+        """
+        # 1. Validate and prepare the template string from the output_format
+        if isinstance(output_format, dict):
+            # Convert the dictionary to a nicely formatted JSON string for the template
+            template_str = json.dumps(output_format, indent=2)
+        elif isinstance(output_format, str):
+            # Assume it's already a valid JSON string template
+            template_str = output_format
+        else:
+            # It's good practice to fail early for invalid input types
+            raise TypeError("output_format must be a dict or a JSON string.")
+
+        # 2. Construct a specialized system prompt for structured data generation
+        system_prompt = (
+            "You are a highly skilled AI assistant that processes user requests "
+            "and returns structured data in JSON format. You must strictly adhere "
+            "to the provided JSON template, filling in the values accurately based "
+            "on the user's prompt. Do not add any commentary, explanations, or text "
+            "outside of the final JSON code block. Your entire response must be a single "
+            "valid JSON object within a markdown code block."
+        )
+        if extra_system_prompt:
+            system_prompt += f"\n\nAdditional instructions:\n{extra_system_prompt}"
+
+        # 3. Call the underlying generate_code method with JSON-specific settings
+        if kwargs.get('debug'):
+            ASCIIColors.info("Generating structured content...")
+
+        json_string = self.generate_code(
+            prompt=prompt,
+            system_prompt=system_prompt,
+            template=template_str,
+            language="json",
+            code_tag_format="markdown", # Sticking to markdown is generally more reliable
+            **kwargs # Pass other params like temperature, top_k, etc.
+        )
+
+        # 4. Parse the result and return
+        if not json_string:
+            # generate_code already logs the error, so no need for another message
+            return None
+
+        if kwargs.get('debug'):
+            ASCIIColors.info("Parsing generated JSON string...")
+            print(f"--- Raw JSON String ---\n{json_string}\n-----------------------")
+
+        try:
+            # Use the provided robust parser
+            parsed_json = self.robust_json_parser(json_string)
+            
+            if parsed_json is None:
+                ASCIIColors.warning("Failed to robustly parse the generated JSON.")
+                return None
+                
+            return parsed_json
+
+        except Exception as e:
+            ASCIIColors.error(f"An unexpected error occurred during JSON parsing: {e}")
+            return None
+
 
     def extract_code_blocks(self, text: str, format: str = "markdown") -> List[dict]:
         """

{lollms_client-0.26.0 → lollms_client-0.27.0}/lollms_client/lollms_discussion.py

@@ -374,7 +374,9 @@ class LollmsDiscussion:
         object.__setattr__(self, '_message_index', None)
         object.__setattr__(self, '_messages_to_delete_from_db', set())
         object.__setattr__(self, '_is_db_backed', db_manager is not None)
-
+        
+        object.__setattr__(self, '_system_prompt', None)
+        
         if self._is_db_backed:
             if not db_discussion_obj and not discussion_id:
                 raise ValueError("Either discussion_id or db_discussion_obj must be provided for DB-backed discussions.")
@@ -634,6 +636,9 @@ class LollmsDiscussion:
             A dictionary with 'user_message' and 'ai_message' LollmsMessage objects,
             where the 'ai_message' will contain rich metadata if an agentic turn was used.
         """
+        if personality is not None:
+            object.__setattr__(self, '_system_prompt', personality.system_prompt)
+            
         if self.max_context_size is not None:
             self.summarize_and_prune(self.max_context_size)
 
@@ -684,6 +689,7 @@ class LollmsDiscussion:
                 use_data_store=use_data_store,
                 max_reasoning_steps=max_reasoning_steps,
                 images=images,
+                system_prompt = self._system_prompt,
                 debug=debug, # Pass the debug flag down
                 **kwargs
             )
@@ -880,7 +886,7 @@ class LollmsDiscussion:
             return "" if format_type == "lollms_text" else []
 
         branch = self.get_branch(branch_tip_id)
-        full_system_prompt = self.system_prompt # Simplified for clarity
+        full_system_prompt = self._system_prompt # Simplified for clarity
         participants = self.participants or {}
 
         def get_full_content(msg: 'LollmsMessage') -> str:
@@ -941,7 +947,10 @@ class LollmsDiscussion:
         # --- OPENAI & OLLAMA CHAT FORMATS ---
         messages = []
         if full_system_prompt:
-            messages.append({"role": "system", "content": full_system_prompt})
+            if format_type == "markdown":
+                messages.append(f"system: {full_system_prompt}")
+            else:
+                messages.append({"role": "system", "content": full_system_prompt})
 
         for msg in branch:
             if msg.sender_type == 'user':
@@ -1055,4 +1064,4 @@ class LollmsDiscussion:
             self.commit()
             return discussion_title
         except Exception as ex:
-            trace_exception(ex)
+            trace_exception(ex)

{lollms_client-0.26.0 → lollms_client-0.27.0}/lollms_client/lollms_llm_binding.py

@@ -302,3 +302,7 @@ class LollmsLLMBindingManager:
             list[str]: List of binding names.
         """
         return [binding_dir.name for binding_dir in self.llm_bindings_dir.iterdir() if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]
+
+def get_available_bindings():
+    bindings_dir = Path(__file__).parent/"llm_bindings"
+    return [binding_dir.name for binding_dir in bindings_dir.iterdir() if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]

{lollms_client-0.26.0 → lollms_client-0.27.0}/lollms_client.egg-info/PKG-INFO

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

{lollms_client-0.26.0 → lollms_client-0.27.0}/lollms_client.egg-info/SOURCES.txt

@@ -54,6 +54,7 @@ lollms_client/llm_bindings/__init__.py
 lollms_client/llm_bindings/azure_openai/__init__.py
 lollms_client/llm_bindings/claude/__init__.py
 lollms_client/llm_bindings/gemini/__init__.py
+lollms_client/llm_bindings/grok/__init__.py
 lollms_client/llm_bindings/groq/__init__.py
 lollms_client/llm_bindings/hugging_face_inference_api/__init__.py
 lollms_client/llm_bindings/litellm/__init__.py