lollms-client 1.4.0__py3-none-any.whl → 1.4.1__py3-none-any.whl

lollms_client/__init__.py

@@ -8,7 +8,7 @@ from lollms_client.lollms_utilities import PromptReshaper # Keep general utiliti
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 from lollms_client.lollms_llm_binding import LollmsLLMBindingManager
 
-__version__ = "1.4.0" # Updated version
+__version__ = "1.4.1" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/lollms_core.py

@@ -3921,23 +3921,35 @@ FINAL RESPONSE:"""
                         repeat_penalty:float|None=None,
                         repeat_last_n:int|None=None,
                         callback=None,
-                        debug:bool=False ):
+                        debug:bool=False,
+                        override_all_prompts:bool=False ):
         """
         Generates a single code block based on a prompt.
         Uses the underlying LLM binding via `generate_text`.
         Handles potential continuation if the code block is incomplete.
+        
+        Args:
+            override_all_prompts: If True, uses only the provided prompt and system_prompt 
+                                without any internal prompt engineering or modifications.
         """
-        if not  system_prompt:
-            system_prompt = f"""Act as a code generation assistant that generates code from user prompt."""
+        
+        # Use original prompts without modification if override is enabled
+        if override_all_prompts:
+            final_system_prompt = system_prompt if system_prompt else ""
+            final_prompt = prompt
+        else:
+            # Original prompt engineering logic
+            if not system_prompt:
+                system_prompt = f"""Act as a code generation assistant that generates code from user prompt."""
 
-        if template and template !="{}":
-            if language in ["json","yaml","xml"]:
-                system_prompt += f"\nMake sure the generated context follows the following schema:\n```{language}\n{template}\n```\n"
-            else:
-                system_prompt += f"\nHere is a template of the answer:\n```{language}\n{template}\n```\n"
-            
-            if code_tag_format=="markdown":
-                system_prompt += f"""You must answer with the code placed inside the markdown code tag:
+            if template and template !="{}":
+                if language in ["json","yaml","xml"]:
+                    system_prompt += f"\nMake sure the generated context follows the following schema:\n```{language}\n{template}\n```\n"
+                else:
+                    system_prompt += f"\nHere is a template of the answer:\n```{language}\n{template}\n```\n"
+                
+                if code_tag_format=="markdown":
+                    system_prompt += f"""You must answer with the code placed inside the markdown code tag:
 ```{language}
 ```
 """
@@ -3946,14 +3958,17 @@ FINAL RESPONSE:"""
 <code language="{language}">
 </code>
 """
-        system_prompt += f"""You must return a single code tag.
+            system_prompt += f"""You must return a single code tag.
 Do not split the code in multiple tags.
 {self.ai_full_header}"""
+            
+            final_system_prompt = system_prompt
+            final_prompt = prompt
 
         response = self.generate_text(
-            prompt,
+            final_prompt,
             images=images,
-            system_prompt=system_prompt,
+            system_prompt=final_system_prompt,
             n_predict=n_predict,
             temperature=temperature,
             top_k=top_k,
@@ -3964,8 +3979,8 @@ Do not split the code in multiple tags.
             )
 
         if isinstance(response, dict) and not response.get("status", True):
-             ASCIIColors.error(f"Code generation failed: {response.get('error')}")
-             return None
+            ASCIIColors.error(f"Code generation failed: {response.get('error')}")
+            return None
 
         codes = self.extract_code_blocks(response, format=code_tag_format)
         code_content = None
@@ -3975,46 +3990,425 @@ Do not split the code in multiple tags.
             code_content = last_code["content"]
 
             # Handle incomplete code block continuation (simple approach)
-            max_retries = 3 # Limit continuation attempts
-            retries = 0
-            while not last_code["is_complete"] and retries < max_retries:
-                retries += 1
-                ASCIIColors.info(f"Code block seems incomplete. Attempting continuation ({retries}/{max_retries})...")
-                continuation_prompt = f"{prompt}\n\nAssistant:\n{code_content}\n\n{self.user_full_header}The previous code block was incomplete. Continue the code exactly from where it left off. Do not repeat the previous part. Only provide the continuation inside a single {code_tag_format} code tag.\n{self.ai_full_header}"
-
-                continuation_response = self.generate_text(
-                    continuation_prompt,
-                    images=images, # Resend images if needed for context
-                    n_predict=n_predict, # Allow space for continuation
-                    temperature=temperature, # Use same parameters
+            # Skip continuation logic if override_all_prompts is True to respect user's intent
+            if not override_all_prompts:
+                max_retries = 3 # Limit continuation attempts
+                retries = 0
+                while not last_code["is_complete"] and retries < max_retries:
+                    retries += 1
+                    ASCIIColors.info(f"Code block seems incomplete. Attempting continuation ({retries}/{max_retries})...")
+                    continuation_prompt = f"{prompt}\n\nAssistant:\n{code_content}\n\n{self.user_full_header}The previous code block was incomplete. Continue the code exactly from where it left off. Do not repeat the previous part. Only provide the continuation inside a single {code_tag_format} code tag.\n{self.ai_full_header}"
+
+                    continuation_response = self.generate_text(
+                        continuation_prompt,
+                        images=images, # Resend images if needed for context
+                        n_predict=n_predict, # Allow space for continuation
+                        temperature=temperature, # Use same parameters
+                        top_k=top_k,
+                        top_p=top_p,
+                        repeat_penalty=repeat_penalty,
+                        repeat_last_n=repeat_last_n,
+                        streaming_callback=callback
+                    )
+
+                    if isinstance(continuation_response, dict) and not continuation_response.get("status", True):
+                        ASCIIColors.warning(f"Continuation attempt failed: {continuation_response.get('error')}")
+                        break # Stop trying if generation fails
+
+                    continuation_codes = self.extract_code_blocks(continuation_response, format=code_tag_format)
+
+                    if continuation_codes:
+                        new_code_part = continuation_codes[0]["content"]
+                        code_content += "\n" + new_code_part # Append continuation
+                        last_code["is_complete"] = continuation_codes[0]["is_complete"] # Update completeness
+                        if last_code["is_complete"]:
+                            ASCIIColors.info("Code block continuation successful.")
+                            break # Exit loop if complete
+                    else:
+                        ASCIIColors.warning("Continuation response contained no code block.")
+                        break # Stop if no code block found in continuation
+
+                if not last_code["is_complete"]:
+                    ASCIIColors.warning("Code block remained incomplete after multiple attempts.")
+
+        return code_content # Return the (potentially completed) code content or None
+
+
+    def update_code(
+        self,
+        original_code: str,
+        modification_prompt: str,
+        language: str = "python",
+        images=[],
+        system_prompt: str | None = None,
+        patch_format: str = "unified",  # "unified" or "simple"
+        n_predict: int | None = None,
+        temperature: float | None = None,
+        top_k: int | None = None,
+        top_p: float | None = None,
+        repeat_penalty: float | None = None,
+        repeat_last_n: int | None = None,
+        callback=None,
+        debug: bool = False,
+        max_retries: int = 3
+    ):
+        """
+        Updates existing code based on a modification prompt by generating and applying patches.
+        Designed to work reliably even with smaller LLMs.
+        
+        Args:
+            original_code: The original code to be modified
+            modification_prompt: Description of changes to apply to the code
+            language: Programming language of the code
+            patch_format: "unified" for diff-style patches or "simple" for line-based replacements
+            max_retries: Maximum number of attempts if patch generation/application fails
+            
+        Returns:
+            dict: Contains 'success' (bool), 'updated_code' (str or None), 'patch' (str or None), 
+                and 'error' (str or None)
+        """
+        
+        if not original_code or not original_code.strip():
+            return {
+                "success": False,
+                "updated_code": None,
+                "patch": None,
+                "error": "Original code is empty"
+            }
+        
+        # Choose patch format based on LLM capabilities
+        if patch_format == "simple":
+            # Simple format for smaller LLMs - just old/new line pairs
+            patch_system_prompt = f"""You are a code modification assistant.
+You will receive {language} code and a modification request.
+Generate a patch using this EXACT format:
+
+PATCH_START
+REPLACE_LINE: <line_number>
+OLD: <exact_old_line>
+NEW: <new_line>
+REPLACE_LINE: <another_line_number>
+OLD: <exact_old_line>
+NEW: <new_line>
+PATCH_END
+
+For adding lines:
+ADD_AFTER: <line_number>
+NEW: <line_to_add>
+
+For removing lines:
+REMOVE_LINE: <line_number>
+
+Rules:
+- Line numbers start at 1
+- Match OLD lines EXACTLY including whitespace
+- Only include lines that need changes
+- Keep changes minimal and focused"""
+
+        else:  # unified diff format
+            patch_system_prompt = f"""You are a code modification assistant.
+You will receive {language} code and a modification request.
+Generate a unified diff patch showing the changes.
+
+Format your response as:
+```diff
+@@ -start_line,count +start_line,count @@
+ context_line (unchanged)
+-removed_line
++added_line
+ context_line (unchanged)
+```
+
+Rules:
+- Use standard unified diff format
+- Include 1-2 lines of context around changes
+- Be precise with line numbers
+- Keep changes minimal"""
+
+        if system_prompt:
+            patch_system_prompt = system_prompt + "\n\n" + patch_system_prompt
+        
+        # Prepare the prompt with line numbers for reference
+        numbered_code = "\n".join(
+            f"{i+1:4d}: {line}" 
+            for i, line in enumerate(original_code.split("\n"))
+        )
+        
+        patch_prompt = f"""Original {language} code (with line numbers for reference):
+```{language}
+{numbered_code}
+```
+
+Modification request: {modification_prompt}
+
+Generate a patch to apply these changes. Follow the format specified in your instructions exactly."""
+
+        retry_count = 0
+        last_error = None
+        
+        while retry_count < max_retries:
+            try:
+                if debug:
+                    ASCIIColors.info(f"Attempting to generate patch (attempt {retry_count + 1}/{max_retries})")
+                
+                # Generate the patch
+                response = self.generate_text(
+                    patch_prompt,
+                    images=images,
+                    system_prompt=patch_system_prompt,
+                    n_predict=n_predict or 2000,  # Usually patches are not too long
+                    temperature=temperature or 0.3,  # Lower temperature for more deterministic patches
                     top_k=top_k,
                     top_p=top_p,
                     repeat_penalty=repeat_penalty,
                     repeat_last_n=repeat_last_n,
                     streaming_callback=callback
                 )
+                
+                if isinstance(response, dict) and not response.get("status", True):
+                    raise Exception(f"Patch generation failed: {response.get('error')}")
+                
+                # Extract and apply the patch
+                if patch_format == "simple":
+                    updated_code, patch_text = self._apply_simple_patch(original_code, response, debug)
+                else:
+                    updated_code, patch_text = self._apply_unified_patch(original_code, response, debug)
+                
+                if updated_code:
+                    if debug:
+                        ASCIIColors.success("Code successfully updated")
+                    return {
+                        "success": True,
+                        "updated_code": updated_code,
+                        "patch": patch_text,
+                        "error": None
+                    }
+                else:
+                    raise Exception("Failed to apply patch - no valid changes found")
+                    
+            except Exception as e:
+                last_error = str(e)
+                if debug:
+                    ASCIIColors.warning(f"Attempt {retry_count + 1} failed: {last_error}")
+                
+                retry_count += 1
+                
+                # Try simpler approach on retry
+                if retry_count < max_retries and patch_format == "unified":
+                    patch_format = "simple"
+                    if debug:
+                        ASCIIColors.info("Switching to simple patch format for next attempt")
+        
+        # All retries exhausted
+        return {
+            "success": False,
+            "updated_code": None,
+            "patch": None,
+            "error": f"Failed after {max_retries} attempts. Last error: {last_error}"
+        }
 
-                if isinstance(continuation_response, dict) and not continuation_response.get("status", True):
-                    ASCIIColors.warning(f"Continuation attempt failed: {continuation_response.get('error')}")
-                    break # Stop trying if generation fails
 
-                continuation_codes = self.extract_code_blocks(continuation_response, format=code_tag_format)
+    def _apply_simple_patch(self, original_code: str, patch_response: str, debug: bool = False):
+        """
+        Apply a simple line-based patch to the original code.
+        
+        Returns:
+            tuple: (updated_code or None, patch_text or None)
+        """
+        try:
+            lines = original_code.split("\n")
+            patch_lines = []
+            
+            # Extract patch content
+            if "PATCH_START" in patch_response and "PATCH_END" in patch_response:
+                start_idx = patch_response.index("PATCH_START")
+                end_idx = patch_response.index("PATCH_END")
+                patch_content = patch_response[start_idx + len("PATCH_START"):end_idx].strip()
+            else:
+                # Try to extract patch instructions even without markers
+                patch_content = patch_response
+            
+            # Track modifications to apply them in reverse order (to preserve line numbers)
+            modifications = []
+            
+            for line in patch_content.split("\n"):
+                line = line.strip()
+                if not line:
+                    continue
+                    
+                patch_lines.append(line)
+                
+                if line.startswith("REPLACE_LINE:"):
+                    try:
+                        line_num = int(line.split(":")[1].strip()) - 1  # Convert to 0-based
+                        # Look for OLD and NEW in next lines
+                        idx = patch_content.index(line)
+                        remaining = patch_content[idx:].split("\n")
+                        
+                        old_line = None
+                        new_line = None
+                        
+                        for next_line in remaining[1:]:
+                            if next_line.strip().startswith("OLD:"):
+                                old_line = next_line[next_line.index("OLD:") + 4:].strip()
+                            elif next_line.strip().startswith("NEW:"):
+                                new_line = next_line[next_line.index("NEW:") + 4:].strip()
+                                break
+                        
+                        if old_line is not None and new_line is not None:
+                            modifications.append(("replace", line_num, old_line, new_line))
+                            
+                    except (ValueError, IndexError) as e:
+                        if debug:
+                            ASCIIColors.warning(f"Failed to parse REPLACE_LINE: {e}")
+                            
+                elif line.startswith("ADD_AFTER:"):
+                    try:
+                        line_num = int(line.split(":")[1].strip()) - 1
+                        # Look for NEW in next line
+                        idx = patch_content.index(line)
+                        remaining = patch_content[idx:].split("\n")
+                        
+                        for next_line in remaining[1:]:
+                            if next_line.strip().startswith("NEW:"):
+                                new_line = next_line[next_line.index("NEW:") + 4:].strip()
+                                modifications.append(("add_after", line_num, None, new_line))
+                                break
+                                
+                    except (ValueError, IndexError) as e:
+                        if debug:
+                            ASCIIColors.warning(f"Failed to parse ADD_AFTER: {e}")
+                            
+                elif line.startswith("REMOVE_LINE:"):
+                    try:
+                        line_num = int(line.split(":")[1].strip()) - 1
+                        modifications.append(("remove", line_num, None, None))
+                        
+                    except (ValueError, IndexError) as e:
+                        if debug:
+                            ASCIIColors.warning(f"Failed to parse REMOVE_LINE: {e}")
+            
+            if not modifications:
+                return None, None
+            
+            # Sort modifications by line number in reverse order
+            modifications.sort(key=lambda x: x[1], reverse=True)
+            
+            # Apply modifications
+            for mod_type, line_num, old_line, new_line in modifications:
+                if line_num < 0 or line_num >= len(lines):
+                    if debug:
+                        ASCIIColors.warning(f"Line number {line_num + 1} out of range")
+                    continue
+                    
+                if mod_type == "replace":
+                    # Verify old line matches (with some flexibility for whitespace)
+                    if old_line and lines[line_num].strip() == old_line.strip():
+                        # Preserve original indentation
+                        indent = len(lines[line_num]) - len(lines[line_num].lstrip())
+                        lines[line_num] = " " * indent + new_line.lstrip()
+                    elif debug:
+                        ASCIIColors.warning(f"Line {line_num + 1} doesn't match expected content")
+                        
+                elif mod_type == "add_after":
+                    # Get indentation from the reference line
+                    indent = len(lines[line_num]) - len(lines[line_num].lstrip())
+                    lines.insert(line_num + 1, " " * indent + new_line.lstrip())
+                    
+                elif mod_type == "remove":
+                    del lines[line_num]
+            
+            updated_code = "\n".join(lines)
+            patch_text = "\n".join(patch_lines)
+            
+            return updated_code, patch_text
+            
+        except Exception as e:
+            if debug:
+                ASCIIColors.error(f"Error applying simple patch: {e}")
+            return None, None
 
-                if continuation_codes:
-                    new_code_part = continuation_codes[0]["content"]
-                    code_content += "\n" + new_code_part # Append continuation
-                    last_code["is_complete"] = continuation_codes[0]["is_complete"] # Update completeness
-                    if last_code["is_complete"]:
-                        ASCIIColors.info("Code block continuation successful.")
-                        break # Exit loop if complete
-                else:
-                     ASCIIColors.warning("Continuation response contained no code block.")
-                     break # Stop if no code block found in continuation
 
-            if not last_code["is_complete"]:
-                ASCIIColors.warning("Code block remained incomplete after multiple attempts.")
+    def _apply_unified_patch(self, original_code: str, patch_response: str, debug: bool = False):
+        """
+        Apply a unified diff patch to the original code.
+        
+        Returns:
+            tuple: (updated_code or None, patch_text or None)
+        """
+        try:
+            import re
+            
+            lines = original_code.split("\n")
+            
+            # Extract diff content
+            diff_pattern = r'```diff\n(.*?)\n```'
+            diff_match = re.search(diff_pattern, patch_response, re.DOTALL)
+            
+            if diff_match:
+                patch_text = diff_match.group(1)
+            else:
+                # Try to find diff content without code blocks
+                if "@@" in patch_response:
+                    patch_text = patch_response
+                else:
+                    return None, None
+            
+            # Parse and apply hunks
+            hunk_pattern = r'@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@'
+            hunks = re.finditer(hunk_pattern, patch_text)
+            
+            changes = []
+            for hunk in hunks:
+                old_start = int(hunk.group(1)) - 1  # Convert to 0-based
+                old_count = int(hunk.group(2)) if hunk.group(2) else 1
+                new_start = int(hunk.group(3)) - 1
+                new_count = int(hunk.group(4)) if hunk.group(4) else 1
+                
+                # Extract hunk content
+                hunk_start = hunk.end()
+                next_hunk = re.search(hunk_pattern, patch_text[hunk_start:])
+                hunk_end = hunk_start + next_hunk.start() if next_hunk else len(patch_text)
+                
+                hunk_lines = patch_text[hunk_start:hunk_end].strip().split("\n")
+                
+                # Process hunk lines
+                for line in hunk_lines:
+                    if not line:
+                        continue
+                        
+                    if line.startswith("-"):
+                        changes.append(("remove", old_start, line[1:].strip()))
+                    elif line.startswith("+"):
+                        changes.append(("add", old_start, line[1:].strip()))
+                    # Context lines (starting with space) are ignored
+            
+            # Apply changes (in reverse order to maintain line numbers)
+            changes.sort(key=lambda x: x[1], reverse=True)
+            
+            for change_type, line_num, content in changes:
+                if line_num < 0 or line_num > len(lines):
+                    continue
+                    
+                if change_type == "remove":
+                    if line_num < len(lines) and lines[line_num].strip() == content:
+                        del lines[line_num]
+                elif change_type == "add":
+                    # Preserve indentation from nearby lines
+                    indent = 0
+                    if line_num > 0:
+                        indent = len(lines[line_num - 1]) - len(lines[line_num - 1].lstrip())
+                    lines.insert(line_num, " " * indent + content)
+            
+            updated_code = "\n".join(lines)
+            
+            return updated_code, patch_text
+            
+        except Exception as e:
+            if debug:
+                ASCIIColors.error(f"Error applying unified patch: {e}")
+            return None, None
 
-        return code_content # Return the (potentially completed) code content or None
 
     def generate_structured_content(
         self,
@@ -4023,8 +4417,16 @@ Do not split the code in multiple tags.
         schema=None,
         system_prompt=None,
         max_retries=1,
+        use_override=False,
         **kwargs
     ):
+        """
+        Enhanced structured content generation with optional prompt override.
+        
+        Args:
+            use_override: If True, uses override_all_prompts=True in generate_code
+                        and relies entirely on provided system_prompt and prompt.
+        """
         import json
         images = [] if images is None else images
         schema = {} if schema is None else schema
@@ -4044,21 +4446,15 @@ Do not split the code in multiple tags.
         else:
             raise TypeError("schema must be a dict or a JSON string.")
 
-        # --- FIX STARTS HERE ---
         # Heuristic to detect if the schema is a properties-only dictionary
-        # and needs to be wrapped in a root object to be a valid schema.
-        # This handles cases where the user provides `{"field1": {...}, "field2": {...}}`
-        # instead of `{"type": "object", "properties": {"field1": ...}}`.
         if "type" not in schema_obj and "properties" not in schema_obj and all(isinstance(v, dict) for v in schema_obj.values()):
             if kwargs.get("debug"):
                 ASCIIColors.info("Schema appears to be a properties-only dictionary; wrapping it in a root object.")
             schema_obj = {
                 "type": "object",
                 "properties": schema_obj,
-                # Assume all top-level keys are required when wrapping
                 "required": list(schema_obj.keys())
             }
-        # --- FIX ENDS HERE ---
 
         def _instance_skeleton(s):
             if not isinstance(s, dict):
@@ -4068,7 +4464,6 @@ Do not split the code in multiple tags.
             if "enum" in s and isinstance(s["enum"], list) and s["enum"]:
                 return s["enum"][0]
             
-            # Handle default values
             if "default" in s:
                 return s["default"]
 
@@ -4082,22 +4477,19 @@ Do not split the code in multiple tags.
             if t == "boolean":
                 return False
             if t == "array":
-                # Generate one minimal item if schema is provided
                 items = s.get("items", {})
                 min_items = s.get("minItems", 0)
-                # Let's generate at least one item for the example if possible
                 num_items = max(min_items, 1) if items and not min_items == 0 else min_items
                 return [_instance_skeleton(items) for _ in range(num_items)]
             if t == "object":
                 props = s.get("properties", {})
-                # Use required fields, otherwise fall back to all properties for the skeleton
                 req = s.get("required", list(props.keys()))
                 out = {}
                 for k in req:
                     if k in props:
                         out[k] = _instance_skeleton(props[k])
                     else:
-                        out[k] = None # Should not happen if schema is well-formed
+                        out[k] = None
                 return out
             if "oneOf" in s and isinstance(s["oneOf"], list) and s["oneOf"]:
                 return _instance_skeleton(s["oneOf"][0])
@@ -4112,42 +4504,56 @@ Do not split the code in multiple tags.
                 return merged if merged else {}
             return {}
 
-        # Now derive strings from the (potentially corrected) schema_obj
         schema_str = json.dumps(schema_obj, indent=2, ensure_ascii=False)
         example_obj = _instance_skeleton(schema_obj)
         example_str = json.dumps(example_obj, indent=2, ensure_ascii=False)
 
-        base_system = (
-            "Your objective is to generate a JSON object that satisfies the user's request and conforms to the provided schema.\n"
-            "Rules:\n"
-            "1) The schema is reference ONLY. Do not include the schema in the output.\n"
-            "2) Output exactly ONE valid JSON object.\n"
-            "3) Wrap the JSON object inside a single ```json code block.\n"
-            "4) Do not output explanations or text outside the JSON.\n"
-            "5) Use 2 spaces for indentation. Do not use tabs.\n"
-            "6) Only include fields allowed by the schema and ensure all required fields are present.\n"
-            "7) For enums, choose a valid value from the list.\n\n"
-            "Schema (reference only):\n"
-            f"```json\n{schema_str}\n```\n\n"
-            "Correct example of output format (structure only, values are illustrative):\n"
-            f"```json\n{example_str}\n```"
-        )
-        full_system_prompt = f"{system_prompt}\n\n{base_system}" if system_prompt else base_system
+        if use_override:
+            # Use provided system_prompt and prompt as-is
+            final_system_prompt = system_prompt if system_prompt else ""
+            final_prompt = prompt
+            override_prompts = True
+        else:
+            # Use original prompt engineering
+            base_system = (
+                "Your objective is to generate a JSON object that satisfies the user's request and conforms to the provided schema.\n"
+                "Rules:\n"
+                "1) The schema is reference ONLY. Do not include the schema in the output.\n"
+                "2) Output exactly ONE valid JSON object.\n"
+                "3) Wrap the JSON object inside a single ```json code block.\n"
+                "4) Do not output explanations or text outside the JSON.\n"
+                "5) Use 2 spaces for indentation. Do not use tabs.\n"
+                "6) Only include fields allowed by the schema and ensure all required fields are present.\n"
+                "7) For enums, choose a valid value from the list.\n\n"
+                "Schema (reference only):\n"
+                f"```json\n{schema_str}\n```\n\n"
+                "Correct example of output format (structure only, values are illustrative):\n"
+                f"```json\n{example_str}\n```"
+            )
+            final_system_prompt = f"{system_prompt}\n\n{base_system}" if system_prompt else base_system
+            final_prompt = prompt
+            override_prompts = False
 
         if kwargs.get("debug"):
             ASCIIColors.info("Generating structured content...")
 
         last_error = None
         for attempt in range(max_retries + 1):
+            retry_system_prompt = final_system_prompt
+            if attempt > 0 and not use_override:
+                retry_system_prompt = f"{final_system_prompt}\n\nPrevious attempt failed validation: {last_error}\nReturn a corrected JSON instance that strictly satisfies the schema."
+            
             json_string = self.generate_code(
-                prompt=prompt,
+                prompt=final_prompt,
                 images=images,
-                system_prompt=full_system_prompt if attempt == 0 else f"{full_system_prompt}\n\nPrevious attempt failed validation: {last_error}\nReturn a corrected JSON instance that strictly satisfies the schema.",
-                template=example_str,
+                system_prompt=retry_system_prompt,
+                template=example_str if not use_override else None,
                 language="json",
                 code_tag_format="markdown",
+                override_all_prompts=override_prompts,
                 **kwargs
             )
+            
             if not json_string:
                 last_error = "LLM returned an empty response."
                 if kwargs.get("debug"): ASCIIColors.warning(last_error)
@@ -4173,19 +4579,213 @@ Do not split the code in multiple tags.
                         if kwargs.get("debug"): ASCIIColors.warning(last_error)
                         if attempt < max_retries:
                             continue
-                        # Return the invalid object after last retry if validation fails
                         return parsed_json
                 return parsed_json
             except Exception as e:
                 trace_exception(e)
                 ASCIIColors.error(f"Unexpected error during JSON processing: {e}")
                 last_error = f"An unexpected error occurred: {e}"
-                # Do not retry on unexpected errors, break the loop
                 break
         
         ASCIIColors.error(f"Failed to generate valid structured content after {max_retries + 1} attempts. Last error: {last_error}")
         return None
 
+    def generate_structured_content_pydantic(
+        self,
+        prompt,
+        pydantic_model,
+        images=None,
+        system_prompt=None,
+        max_retries=1,
+        use_override=False,
+        **kwargs
+    ):
+        """
+        Generate structured content using Pydantic models for validation.
+        
+        Args:
+            prompt: The user prompt
+            pydantic_model: A Pydantic BaseModel class or instance
+            images: Optional images for context
+            system_prompt: Optional system prompt
+            max_retries: Number of retry attempts
+            use_override: If True, uses override_all_prompts=True in generate_code
+            **kwargs: Additional arguments passed to generate_code
+            
+        Returns:
+            Validated Pydantic model instance or None if generation failed
+        """
+        import json
+        from typing import get_type_hints, get_origin, get_args
+        
+        try:
+            from pydantic import BaseModel, ValidationError
+            from pydantic.fields import FieldInfo
+        except ImportError:
+            ASCIIColors.error("Pydantic is required for this method. Please install it with: pip install pydantic")
+            return None
+        
+        images = [] if images is None else images
+        
+        # Handle both class and instance
+        if isinstance(pydantic_model, type) and issubclass(pydantic_model, BaseModel):
+            model_class = pydantic_model
+        elif isinstance(pydantic_model, BaseModel):
+            model_class = type(pydantic_model)
+        else:
+            raise TypeError("pydantic_model must be a Pydantic BaseModel class or instance")
+        
+        def _get_pydantic_schema_info(model_cls):
+            """Extract schema information from Pydantic model."""
+            schema = model_cls.model_json_schema()
+            
+            # Create example instance
+            try:
+                # Try to create with defaults first
+                example_instance = model_cls()
+                example_dict = example_instance.model_dump()
+            except:
+                # If that fails, create minimal example based on schema
+                example_dict = _create_example_from_schema(schema)
+            
+            return schema, example_dict
+        
+        def _create_example_from_schema(schema):
+            """Create example data from JSON schema."""
+            if schema.get("type") == "object":
+                properties = schema.get("properties", {})
+                required = schema.get("required", [])
+                example = {}
+                
+                for field_name, field_schema in properties.items():
+                    if field_name in required or "default" in field_schema:
+                        example[field_name] = _get_example_value(field_schema)
+                
+                return example
+            return {}
+        
+        def _get_example_value(field_schema):
+            """Get example value for a field based on its schema."""
+            if "default" in field_schema:
+                return field_schema["default"]
+            if "const" in field_schema:
+                return field_schema["const"]
+            if "enum" in field_schema and field_schema["enum"]:
+                return field_schema["enum"][0]
+            
+            field_type = field_schema.get("type")
+            if field_type == "string":
+                return "example"
+            elif field_type == "integer":
+                return 0
+            elif field_type == "number":
+                return 0.0
+            elif field_type == "boolean":
+                return False
+            elif field_type == "array":
+                items_schema = field_schema.get("items", {})
+                return [_get_example_value(items_schema)]
+            elif field_type == "object":
+                return _create_example_from_schema(field_schema)
+            else:
+                return None
+        
+        # Get schema and example from Pydantic model
+        try:
+            schema, example_dict = _get_pydantic_schema_info(model_class)
+            schema_str = json.dumps(schema, indent=2, ensure_ascii=False)
+            example_str = json.dumps(example_dict, indent=2, ensure_ascii=False)
+        except Exception as e:
+            ASCIIColors.error(f"Failed to extract schema from Pydantic model: {e}")
+            return None
+        
+        if use_override:
+            # Use provided system_prompt and prompt as-is
+            final_system_prompt = system_prompt if system_prompt else ""
+            final_prompt = prompt
+            override_prompts = True
+        else:
+            # Enhanced prompt engineering for Pydantic
+            base_system = (
+                "Your objective is to generate a JSON object that satisfies the user's request and conforms to the provided Pydantic model schema.\n"
+                "Rules:\n"
+                "1) The schema is reference ONLY. Do not include the schema in the output.\n"
+                "2) Output exactly ONE valid JSON object that can be parsed by the Pydantic model.\n"
+                "3) Wrap the JSON object inside a single ```json code block.\n"
+                "4) Do not output explanations or text outside the JSON.\n"
+                "5) Use 2 spaces for indentation. Do not use tabs.\n"
+                "6) Respect all field types, constraints, and validation rules.\n"
+                "7) Include all required fields and use appropriate default values where specified.\n"
+                "8) For enums, choose a valid value from the allowed options.\n\n"
+                f"Pydantic Model Schema (reference only):\n"
+                f"```json\n{schema_str}\n```\n\n"
+                "Correct example of output format (structure only, values are illustrative):\n"
+                f"```json\n{example_str}\n```"
+            )
+            final_system_prompt = f"{system_prompt}\n\n{base_system}" if system_prompt else base_system
+            final_prompt = prompt
+            override_prompts = False
+        
+        if kwargs.get("debug"):
+            ASCIIColors.info("Generating Pydantic-structured content...")
+            ASCIIColors.info(f"Using model: {model_class.__name__}")
+        
+        last_error = None
+        for attempt in range(max_retries + 1):
+            retry_system_prompt = final_system_prompt
+            if attempt > 0:
+                retry_system_prompt = f"{final_system_prompt}\n\nPrevious attempt failed Pydantic validation: {last_error}\nReturn a corrected JSON instance that strictly satisfies the Pydantic model."
+            
+            json_string = self.generate_code(
+                prompt=prompt,
+                images=images,
+                system_prompt=retry_system_prompt,
+                language="json",
+                code_tag_format="markdown",
+                override_all_prompts=True,  # Always use override for structured content
+                **kwargs
+            )
+            
+            if not json_string:
+                last_error = "LLM returned an empty response."
+                if kwargs.get("debug"): ASCIIColors.warning(last_error)
+                continue
+            
+            if kwargs.get("debug"):
+                ASCIIColors.info("Parsing generated JSON string...")
+                print(f"--- Raw JSON String ---\n{json_string}\n-----------------------")
+            
+            try:
+                # Parse JSON
+                parsed_json = robust_json_parser(json_string)
+                if parsed_json is None:
+                    last_error = "Failed to robustly parse the generated string into JSON."
+                    if kwargs.get("debug"): ASCIIColors.warning(last_error)
+                    continue
+                
+                # Validate with Pydantic
+                try:
+                    validated_instance = model_class.model_validate(parsed_json)
+                    if kwargs.get("debug"):
+                        ASCIIColors.success("Pydantic validation successful!")
+                    return validated_instance
+                except ValidationError as ve:
+                    last_error = f"Pydantic Validation Error: {ve}"
+                    if kwargs.get("debug"): ASCIIColors.warning(last_error)
+                    if attempt < max_retries:
+                        continue
+                    # Return the raw parsed JSON if validation fails on last attempt
+                    ASCIIColors.warning("Returning unvalidated JSON after final attempt.")
+                    return parsed_json
+                    
+            except Exception as e:
+                trace_exception(e)
+                ASCIIColors.error(f"Unexpected error during JSON processing: {e}")
+                last_error = f"An unexpected error occurred: {e}"
+                break
+    
+        ASCIIColors.error(f"Failed to generate valid Pydantic-structured content after {max_retries + 1} attempts. Last error: {last_error}")
+        return None
 
     def extract_code_blocks(self, text: str, format: str = "markdown") -> List[dict]:
         """

lollms_client/lollms_discussion.py

@@ -1707,21 +1707,25 @@ class LollmsDiscussion:
             )
 
             if memory_json and memory_json.get("title") and memory_json.get("content"):
-                title = memory_json["title"]
-                self.add_memory(
-                    title=title,
-                    content=memory_json["content"]
-                )
-                # Automatically load the newly created memory into the context
-                self.load_memory_into_context(title)
                 print(f"[INFO] Memorize: New memory created and loaded into context: '{title}'.")
+                return memory_json
             else:
                 print("[WARNING] Memorize: Failed to generate a valid memory from the discussion.")
-                
+                return None
         except Exception as e:
             trace_exception(e)
             print(f"[ERROR] Memorize: Failed to create memory. {e}")
 
+        def set_memory(self, memory_text: str):
+            """Sets the discussion's memory content.
+            This memory is included in the system context during exports and can be
+            used to provide background information or retain important details across turns.
+            Args:
+                memory_text: The text to set as the discussion's memory.
+            """       
+            self.memory = memory_text.strip()
+            self.touch()
+
     def count_discussion_tokens(self, format_type: str, branch_tip_id: Optional[str] = None) -> int:
         """Counts the number of tokens in the exported discussion content.
 
@@ -2363,7 +2367,7 @@ class LollmsDiscussion:
         
         return self.add_artefact(
             title, content=new_content, images=new_images,
-            audios=latest_artefact.get("audios", []), videos=latest_artefact.get("videos", []),
+            audios=latest_artefact.get("audios", []),videos=latest_artefact.get("videos", []),
             zip_content=latest_artefact.get("zip"), version=latest_version + 1, **extra_data
         )
 
@@ -2489,148 +2493,6 @@ class LollmsDiscussion:
             
         return removed_count
 
-    # Memories management system
-    def list_memories(self) -> List[Dict[str, Any]]:
-        """
-        Lists all memories stored in the discussion's metadata.
-        """
-        metadata = self.metadata or {}
-        memories = metadata.get("_memories", [])
-        now = datetime.utcnow().isoformat()
-        
-        upgraded = []
-        dirty = False
-        for memory in memories:
-            fixed = memory.copy()
-            if "title" not in fixed: fixed["title"] = "untitled"; dirty = True
-            if "content" not in fixed: fixed["content"] = ""; dirty = True
-            if "created_at" not in fixed: fixed["created_at"] = now; dirty = True
-            
-            section_start = f"--- Memory: {fixed['title']} ---"
-            fixed["is_loaded"] = section_start in (self.memory or "")
-            upgraded.append(fixed)
-
-        if dirty:
-            metadata["_memories"] = upgraded
-            self.metadata = metadata
-            self.commit()
-
-        return upgraded
-
-    def add_memory(self, title: str, content: str, **extra_data) -> Dict[str, Any]:
-        """
-        Adds or overwrites a memory in the discussion.
-        """
-        new_metadata = (self.metadata or {}).copy()
-        memories = new_metadata.get("_memories", [])
-        
-        memories = [m for m in memories if m.get('title') != title]
-
-        new_memory = {
-            "title": title, "content": content,
-            "created_at": datetime.utcnow().isoformat(),
-            **extra_data
-        }
-        memories.append(new_memory)
-        
-        new_metadata["_memories"] = memories
-        self.metadata = new_metadata
-        self.commit()
-        return new_memory
-
-    def get_memory(self, title: str) -> Optional[Dict[str, Any]]:
-        """
-        Retrieves a memory by title.
-        """
-        memories = self.list_memories()
-        return next((m for m in memories if m.get('title') == title), None)
-
-    def load_memory_into_context(self, title: str):
-        """
-        Loads a memory's content into the long-term memory context.
-        """
-        memory = self.get_memory(title)
-        if not memory:
-            raise ValueError(f"Memory '{title}' not found.")
-
-        if memory.get('content'):
-            section = (
-                f"--- Memory: {memory['title']} ---\n"
-                f"{memory['content']}\n"
-                f"--- End Memory: {memory['title']} ---\n\n"
-            )
-            if section not in (self.memory or ""):
-                current_memory_zone = self.memory or ""
-                self.memory = current_memory_zone.rstrip() + "\n\n" + section
-                self.touch()
-                self.commit()
-                print(f"Loaded memory '{title}' into context.")
-
-    def unload_memory_from_context(self, title: str):
-        """
-        Removes a memory's content from the long-term memory context.
-        """
-        memory = self.get_memory(title)
-        if not memory:
-            raise ValueError(f"Memory '{title}' not found.")
-
-        if self.memory and memory.get('content'):
-            section_start = f"--- Memory: {memory['title']} ---"
-            pattern = rf"\n*\s*{re.escape(section_start)}.*?--- End Memory: {re.escape(memory['title'])} ---\s*\n*"
-            self.memory = re.sub(pattern, "", self.memory, flags=re.DOTALL).strip()
-            self.touch()
-            self.commit()
-            print(f"Unloaded memory '{title}' from context.")
-
-    def is_memory_loaded(self, title: str) -> bool:
-        """
-        Checks if a memory is currently loaded in the long-term memory context.
-        """
-        memory = self.get_memory(title)
-        if not memory:
-            return False
-
-        section_start = f"--- Memory: {memory['title']} ---"
-        return section_start in (self.memory or "")
-
-    def purge_memories(self) -> bool:
-        """
-        Removes all memories from the discussion.
-        
-        Returns:
-            The number of memories removed (0 or 1).
-        """
-        new_metadata = (self.metadata or {}).copy()
-        new_metadata["_memories"] = []
-        self.metadata = new_metadata
-        self.commit()
-        print(f"Removed memory titled.")
-        return True
-
-    def remove_memory(self, title: str) -> int:
-        """
-        Removes a memory by title.
-        
-        Returns:
-            The number of memories removed (0 or 1).
-        """
-        new_metadata = (self.metadata or {}).copy()
-        memories = new_metadata.get("_memories", [])
-        if not memories:
-            return 0
-
-        initial_count = len(memories)
-        kept_memories = [m for m in memories if m.get('title') != title]
-
-        if len(kept_memories) < initial_count:
-            new_metadata["_memories"] = kept_memories
-            self.metadata = new_metadata
-            self.commit()
-            print(f"Removed memory titled '{title}'.")
-            return 1
-            
-        return 0
-
     def clone_without_messages(self) -> 'LollmsDiscussion':
         """
         Creates a new discussion with the same context but no message history.

lollms_client/tti_bindings/diffusers/__init__.py

@@ -131,7 +131,28 @@ CIVITAI_MODELS = {
         "filename": "papercut.safetensors",
         "description": "Paper cutout SD1.5.",
         "owned_by": "civitai"
-    }
+    },
+    "fantassifiedIcons": {
+        "display_name": "Fantassified Icons",
+        "url": "https://civitai.com/api/download/models/67584?type=Model&format=SafeTensor&size=pruned&fp=fp16",
+        "filename": "fantassifiedIcons_fantassifiedIconsV20.safetensors",
+        "description": "Flat, modern Icons.",
+        "owned_by": "civitai"
+    },
+    "game_icon_institute": {
+        "display_name": "Game icon institute",
+        "url": "https://civitai.com/api/download/models/158776?type=Model&format=SafeTensor&size=full&fp=fp16",
+        "filename": "gameIconInstituteV10_v10.safetensors",
+        "description": "Flat, modern game Icons.",
+        "owned_by": "civitai"
+    },
+    "M4RV3LS_DUNGEONS": {
+        "display_name": "M4RV3LS & DUNGEONS",
+        "url": "https://civitai.com/api/download/models/139417?type=Model&format=SafeTensor&size=pruned&fp=fp16",
+        "filename": "M4RV3LSDUNGEONSNEWV40COMICS_mD40.safetensors",
+        "description": "comics.",
+        "owned_by": "civitai"
+    },
 }
 
 TORCH_DTYPE_MAP_STR_TO_OBJ = {
@@ -453,8 +474,8 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
         "safety_checker_on": True,
         "num_inference_steps": 25,
         "guidance_scale": 7.0,
-        "default_width": 512,
-        "default_height": 512,
+        "width": 512,
+        "height": 512,
         "seed": -1,
         "enable_cpu_offload": False,
         "enable_sequential_cpu_offload": False,
@@ -484,6 +505,7 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
         self.config = self.DEFAULT_CONFIG.copy()
         self.config.update(kwargs)
         self.model_name = self.config.get("model_name", "")
+        
         models_path_str = kwargs.get("models_path", str(Path(__file__).parent / "models"))
         self.models_path = Path(models_path_str)
         self.models_path.mkdir(parents=True, exist_ok=True)
@@ -600,11 +622,11 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
         generator = self._prepare_seed(kwargs)
         pipeline_args = {
             "prompt": prompt,
-            "negative_prompt": negative_prompt or None,
-            "width": width if width is not None else self.config["default_width"],
-            "height": height if height is not None else self.config["default_height"],
-            "num_inference_steps": kwargs.pop("num_inference_steps", self.config["num_inference_steps"]),
-            "guidance_scale": kwargs.pop("guidance_scale", self.config["guidance_scale"]),
+            "negative_prompt": negative_prompt or self.config.get("negative_prompt", ""),
+            "width": width if width is not None else self.config.get("width", 512),
+            "height": height if height is not None else self.config.get("height", 512),
+            "num_inference_steps": kwargs.pop("num_inference_steps", self.config.get("num_inference_steps",25)),
+            "guidance_scale": kwargs.pop("guidance_scale", self.config.get("guidance_scale",6.5)),
             "generator": generator
         }
         pipeline_args.update(kwargs)
@@ -646,8 +668,8 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
             self._acquire_manager()
         imgs = [images] if isinstance(images, str) else list(images)
         pil_images = [self._decode_image_input(s) for s in imgs]
-        out_w = width if width is not None else self.config["default_width"]
-        out_h = height if height is not None else self.config["default_height"]
+        out_w = width if width is not None else self.config["width"]
+        out_h = height if height is not None else self.config["height"]
         generator = self._prepare_seed(kwargs)
         steps = kwargs.pop("num_inference_steps", self.config["num_inference_steps"])
         guidance = kwargs.pop("guidance_scale", self.config["guidance_scale"])
@@ -756,8 +778,8 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
             {"name": "enable_cpu_offload", "type": "bool", "value": self.config["enable_cpu_offload"], "description": "Enable model CPU offload (saves VRAM, slower)."},
             {"name": "enable_sequential_cpu_offload", "type": "bool", "value": self.config["enable_sequential_cpu_offload"], "description": "Enable sequential CPU offload."},
             {"name": "enable_xformers", "type": "bool", "value": self.config["enable_xformers"], "description": "Enable xFormers memory efficient attention."},
-            {"name": "default_width", "type": "int", "value": self.config["default_width"], "description": "Default image width."},
-            {"name": "default_height", "type": "int", "value": self.config["default_height"], "description": "Default image height."},
+            {"name": "width", "type": "int", "value": self.config["width"], "description": "Default image width."},
+            {"name": "height", "type": "int", "value": self.config["height"], "description": "Default image height."},
             {"name": "num_inference_steps", "type": "int", "value": self.config["num_inference_steps"], "description": "Default inference steps."},
             {"name": "guidance_scale", "type": "float", "value": self.config["guidance_scale"], "description": "Default guidance scale (CFG)."},
             {"name": "seed", "type": "int", "value": self.config["seed"], "description": "Default seed (-1 for random)."},

{lollms_client-1.4.0.dist-info → lollms_client-1.4.1.dist-info}/METADATA

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

{lollms_client-1.4.0.dist-info → lollms_client-1.4.1.dist-info}/RECORD

@@ -1,8 +1,8 @@
-lollms_client/__init__.py,sha256=qPZONrhBQLJOLMIGp9Z9tMt9xTQ-CulJRwCPSZwXaDY,1146
+lollms_client/__init__.py,sha256=G2ENRPwIlHb_nTaBEbn_AvUQvlsBYpIuQXGWYkYmyo0,1146
 lollms_client/lollms_agentic.py,sha256=pQiMEuB_XkG29-SW6u4KTaMFPr6eKqacInggcCuCW3k,13914
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=TSkwJN0mozPtCOiQQisqMUbZVVkqKKNdpjanOrKDjUM,289087
-lollms_client/lollms_discussion.py,sha256=7O58DCvtd3zJ_W9wbuDOb5zcU6yt27xqSFkiQEH0wpk,127903
+lollms_client/lollms_core.py,sha256=aCEoxmEF6ZmkBgJgZd74lKkM4A3PVVyt2IwMvLfScWw,315053
+lollms_client/lollms_discussion.py,sha256=jWw1lSq0Oz_X5pnkECf1XwdDP2Lf84im00VpwuvsXXk,123041
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
 lollms_client/lollms_llm_binding.py,sha256=Dj1PI2bQBYv_JgPxCIaIC7DMUvWdFJGwXFdsP5hdGBg,25014
 lollms_client/lollms_mcp_binding.py,sha256=psb27A23VFWDfZsR2WUbQXQxiZDW5yfOak6ZtbMfszI,10222
@@ -49,7 +49,7 @@ lollms_client/stt_bindings/lollms/__init__.py,sha256=9Vmn1sQQZKLGLe7nZnc-0LnNeSY
 lollms_client/stt_bindings/whisper/__init__.py,sha256=1Ej67GdRKBy1bba14jMaYDYHiZkxJASkWm5eF07ztDQ,15363
 lollms_client/stt_bindings/whispercpp/__init__.py,sha256=xSAQRjAhljak3vWCpkP0Vmdb6WmwTzPjXyaIB85KLGU,21439
 lollms_client/tti_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client/tti_bindings/diffusers/__init__.py,sha256=KKcIBIQvavAyIwuqappRqLghUOcm-XOP_Y4SL_pEcWY,40669
+lollms_client/tti_bindings/diffusers/__init__.py,sha256=Pi5Zw4nHGXVc0Vcb0ib7KkoiOx__0JukWtL01BUzd7c,41692
 lollms_client/tti_bindings/gemini/__init__.py,sha256=f9fPuqnrBZ1Z-obcoP6EVvbEXNbNCSg21cd5efLCk8U,16707
 lollms_client/tti_bindings/lollms/__init__.py,sha256=5Tnsn4b17djvieQkcjtIDBm3qf0pg5ZWWov-4_2wmo0,8762
 lollms_client/tti_bindings/openai/__init__.py,sha256=YWJolJSQfIzTJvrLQVe8rQewP7rddf6z87g4rnp-lTs,4932
@@ -71,8 +71,8 @@ lollms_client/tts_bindings/xtts/server/main.py,sha256=T-Kn5NM-u1FJMygeV8rOoZKlqn
 lollms_client/tts_bindings/xtts/server/setup_voices.py,sha256=UdHaPa5aNcw8dR-aRGkZr2OfSFFejH79lXgfwT0P3ss,1964
 lollms_client/ttv_bindings/__init__.py,sha256=UZ8o2izQOJLQgtZ1D1cXoNST7rzqW22rL2Vufc7ddRc,3141
 lollms_client/ttv_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client-1.4.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-1.4.0.dist-info/METADATA,sha256=DWMUU9burfwT4loE8WrX5AUzw_TF4p282Ch7yIR-56I,58689
-lollms_client-1.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-1.4.0.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
-lollms_client-1.4.0.dist-info/RECORD,,
+lollms_client-1.4.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-1.4.1.dist-info/METADATA,sha256=eBfpms3EJ5sD7D-xBTXggnqOc1g8IE0inftnXGQmb6w,58689
+lollms_client-1.4.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-1.4.1.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
+lollms_client-1.4.1.dist-info/RECORD,,