lollms-client 1.5.8__py3-none-any.whl → 1.6.0__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.5.8" # Updated version
+__version__ = "1.6.0" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

lollms_client/lollms_core.py

@@ -5732,357 +5732,317 @@ Provide the final aggregated answer in {output_format} format, directly addressi
         callback("Deep analysis complete.", MSG_TYPE.MSG_TYPE_STEP_END)
         return final_output
 
-    def long_context_processing(
-        self,
-        text_to_process: str,
-        contextual_prompt: Optional[str] = None,
-        system_prompt: str= None,
-        context_fill_percentage: float = 0.75,
-        overlap_tokens: int = 0,
-        expected_generation_tokens: int = 1500,
-        streaming_callback: Optional[Callable] = None,
-        return_scratchpad_only: bool = False,
-        debug: bool = True,
-        **kwargs
-    ) -> str:
-        """Enhanced long context processing with Moby Dick literary analysis optimization."""
+def long_context_processing(
+    self,
+    text_to_process: str,
+    contextual_prompt: Optional[str] = None,
+    system_prompt: str | None = None,
+    context_fill_percentage: float = 0.75,
+    overlap_tokens: int = 150,  # Added a default for better context continuity
+    expected_generation_tokens: int = 1500,
+    streaming_callback: Optional[Callable] = None,
+    return_scratchpad_only: bool = False,
+    debug: bool = True,
+    **kwargs
+) -> str:
+    """
+    Processes long text by breaking it down into chunks, analyzing each one incrementally,
+    and synthesizing the results into a comprehensive final response based on a user-defined objective.
+    """
+
+    if debug:
+        print(f"\n🔧 DEBUG: Starting processing with {len(text_to_process):,} characters")
+
+    # Validate context fill percentage
+    if not (0.1 <= context_fill_percentage <= 0.9):
+        raise ValueError(f"context_fill_percentage must be between 0.1 and 0.9, got {context_fill_percentage}")
+
+    # Get context size
+    try:
+        context_size = self.llm.get_context_size() or 8192 # Using a more modern default
+    except:
+        context_size = 8192
+
+    if debug:
+        print(f"🔧 DEBUG: Context size: {context_size}, Fill %: {context_fill_percentage}")
+
+    # Handle empty input
+    if not text_to_process:
+        return ""
+
+    # Use a simple word-based split for token estimation
+    tokens = text_to_process.split()
+    if debug:
+        print(f"🔧 DEBUG: Tokenized into {len(tokens):,} word tokens")
+
+    # Dynamic token budget calculation
+    def calculate_token_budgets(scratchpad_content: str = "", step_num: int = 0) -> dict:
+        # Generic prompt templates are more concise
+        base_system_tokens = 150
+        user_template_tokens = 250
+        scratchpad_tokens = len(scratchpad_content.split()) * 1.3 if scratchpad_content else 0
+
+        used_tokens = base_system_tokens + user_template_tokens + scratchpad_tokens + expected_generation_tokens
+        total_budget = int(context_size * context_fill_percentage)
+        available_for_chunk = max(500, int(total_budget - used_tokens)) # Ensure a reasonable minimum chunk size
+
+        budget_info = {
+            "total_budget": total_budget,
+            "chunk_budget": available_for_chunk,
+            "efficiency_ratio": available_for_chunk / total_budget if total_budget > 0 else 0,
+            "scratchpad_tokens": int(scratchpad_tokens),
+            "used_tokens": int(used_tokens)
+        }
 
         if debug:
-            print(f"\n🔧 DEBUG: Starting processing with {len(text_to_process):,} characters")
+            print(f"🔧 DEBUG Step {step_num}: Budget = {available_for_chunk}/{total_budget} tokens, "
+                  f"Scratchpad = {int(scratchpad_tokens)} tokens")
 
-        # Validate context fill percentage
-        if not (0.1 <= context_fill_percentage <= 0.9):
-            raise ValueError(f"context_fill_percentage must be between 0.1 and 0.9, got {context_fill_percentage}")
+        return budget_info
 
-        # Get context size
-        try:
-            context_size = self.llm.get_context_size() or 4096
-        except:
-            context_size = 4096
+    # Initial budget calculation
+    initial_budget = calculate_token_budgets()
+    chunk_size_tokens = initial_budget["chunk_budget"]
 
-        if debug:
-            print(f"🔧 DEBUG: Context size: {context_size}, Fill %: {context_fill_percentage}")
+    if debug:
+        print(f"🔧 DEBUG: Initial chunk size: {chunk_size_tokens} word tokens")
 
-        # Handle empty input
-        if not text_to_process:
-            return ""
+    if streaming_callback:
+        streaming_callback(
+            f"Context Budget: {initial_budget['chunk_budget']:,}/{initial_budget['total_budget']:,} tokens "
+            f"({initial_budget['efficiency_ratio']:.1%} efficiency)",
+            MSG_TYPE.MSG_TYPE_STEP,
+            {"budget_info": initial_budget}
+        )
 
-        # Use word-based tokenization
-        tokens = text_to_process.split()
+    # Single pass for short content
+    if len(tokens) <= chunk_size_tokens:
         if debug:
-            print(f"🔧 DEBUG: Tokenized into {len(tokens):,} word tokens")
-
-        # Dynamic token budget calculation
-        def calculate_token_budgets(scratchpad_content: str = "", step_num: int = 0) -> dict:
-            base_system_tokens = 250  # Increased for literary-specific prompts
-            user_template_tokens = 300  # Increased for detailed instructions
-            scratchpad_tokens = len(scratchpad_content.split()) * 1.3 if scratchpad_content else 0
-
-            used_tokens = base_system_tokens + user_template_tokens + scratchpad_tokens + expected_generation_tokens
-            total_budget = int(context_size * context_fill_percentage)
-            available_for_chunk = max(400, int(total_budget - used_tokens))  # Increased minimum for better context
-
-            budget_info = {
-                "total_budget": total_budget,
-                "chunk_budget": available_for_chunk,
-                "efficiency_ratio": available_for_chunk / total_budget,
-                "scratchpad_tokens": int(scratchpad_tokens),
-                "used_tokens": int(used_tokens)
-            }
+            print("🔧 DEBUG: Content is short enough for single-pass processing")
 
+        if streaming_callback:
+            streaming_callback("Content fits in a single pass", MSG_TYPE.MSG_TYPE_STEP, {})
+
+        # Generic single-pass system prompt
+        system_prompt = (
+            "You are an expert AI assistant for text analysis and summarization. "
+            "Your task is to carefully analyze the provided text and generate a comprehensive, "
+            "accurate, and well-structured response that directly addresses the user's objective. "
+            "Focus on extracting key information, identifying main themes, and synthesizing the content effectively."
+        )
+
+        prompt_objective = contextual_prompt or "Provide a comprehensive summary and analysis of the provided text."
+        final_prompt = f"Objective: {prompt_objective}\n\n--- Full Text Content ---\n{text_to_process}"
+
+        try:
+            result = self.remove_thinking_blocks(self.llm.generate_text(final_prompt, system_prompt=system_prompt, **kwargs))
             if debug:
-                print(f"🔧 DEBUG Step {step_num}: Budget = {available_for_chunk}/{total_budget} tokens, "
-                      f"Scratchpad = {int(scratchpad_tokens)} tokens")
+                print(f"🔧 DEBUG: Single-pass result: {len(result):,} characters")
+            return result
+        except Exception as e:
+            if debug:
+                print(f"🔧 DEBUG: Single-pass processing failed: {e}")
+            return f"Error in single-pass processing: {e}"
+
+    # Multi-chunk processing for long content
+    if debug:
+        print("🔧 DEBUG: Using multi-chunk processing for long content")
 
-            return budget_info
+    chunk_summaries = []
+    current_position = 0
+    step_number = 1
 
-        # Initial budget calculation
-        initial_budget = calculate_token_budgets()
-        chunk_size_tokens = initial_budget["chunk_budget"]
+    while current_position < len(tokens):
+        # Recalculate budget for each step for dynamic adaptation
+        current_scratchpad = "\n\n---\n\n".join(chunk_summaries)
+        current_budget = calculate_token_budgets(current_scratchpad, step_number)
+        adaptive_chunk_size = max(500, current_budget["chunk_budget"])
+
+        # Extract the next chunk of text
+        chunk_end = min(current_position + adaptive_chunk_size, len(tokens))
+        chunk_tokens = tokens[current_position:chunk_end]
+        chunk_text = " ".join(chunk_tokens)
 
         if debug:
-            print(f"🔧 DEBUG: Initial chunk size: {chunk_size_tokens} word tokens")
+            print(f"\n🔧 DEBUG Step {step_number}: Processing chunk from {current_position} to {chunk_end} "
+                  f"({len(chunk_tokens)} tokens)")
+
+        # Progress calculation
+        remaining_tokens = len(tokens) - current_position
+        estimated_remaining_steps = max(1, -(-remaining_tokens // adaptive_chunk_size)) # Ceiling division
+        total_estimated_steps = step_number + estimated_remaining_steps -1
+        progress = (current_position / len(tokens)) * 90 if len(tokens) > 0 else 0
 
         if streaming_callback:
             streaming_callback(
-                f"Context Budget: {initial_budget['chunk_budget']:,}/{initial_budget['total_budget']:,} tokens "
-                f"({initial_budget['efficiency_ratio']:.1%} efficiency)",
-                MSG_TYPE.MSG_TYPE_STEP,
-                {"budget_info": initial_budget}
+                f"Processing chunk {step_number}/{total_estimated_steps} - "
+                f"Budget: {adaptive_chunk_size:,} tokens",
+                MSG_TYPE.MSG_TYPE_STEP_START,
+                {"step": step_number, "progress": progress}
             )
 
-        # Single pass for short content
-        if len(tokens) <= chunk_size_tokens:
-            if debug:
-                print("🔧 DEBUG: Using single-pass processing")
-
-            if streaming_callback:
-                streaming_callback("Content fits in single pass", MSG_TYPE.MSG_TYPE_STEP, {})
-
-            # FIXED: Moby Dick-specific single-pass system prompt
+        try:
+            # Generic, state-aware system prompt
             system_prompt = (
-                "You are a literary analysis expert specializing in Herman Melville's works. "
-                "Analyze the provided Moby Dick text with deep understanding that Melville's "
-                "detailed realism, technical descriptions, and cultural documentation are "
-                "integral literary techniques. Focus on themes, narrative methods, symbolism, "
-                "and cultural commentary."
+                f"You are a component in a multi-step text processing pipeline. Your role is to analyze a chunk of text and extract key information relevant to a global objective.\n\n"
+                f"**Current Status:** You are on step {step_number} of approximately {total_estimated_steps} steps. Progress is at {progress:.1f}%.\n\n"
+                f"**Your Task:**\n"
+                f"Analyze the 'New Text Chunk' provided below. Extract and summarize any information, data points, or key ideas that are relevant to the 'Global Objective'.\n"
+                f"Review the 'Existing Scratchpad Content' to understand what has already been found. Your goal is to add *new* insights that are not already captured.\n\n"
+                f"**CRITICAL:** Do NOT repeat information already present in the scratchpad. Focus only on new, relevant details from the current chunk. If the chunk contains no new relevant information, respond with '[No new information found in this chunk.]'."
             )
 
-            prompt_objective = contextual_prompt or "Provide comprehensive Moby Dick literary analysis."
-            final_prompt = f"{prompt_objective}\n\n--- Moby Dick Content ---\n{text_to_process}"
-
-            try:
-                result = self.remove_thinking_blocks(self.llm.generate_text(final_prompt, system_prompt=system_prompt, **kwargs))
-                if debug:
-                    print(f"🔧 DEBUG: Single-pass result: {len(result):,} characters")
-                return result
-            except Exception as e:
-                if debug:
-                    print(f"🔧 DEBUG: Single-pass failed: {e}")
-                return f"Error in single-pass processing: {e}"
-
-        # Multi-chunk processing with FIXED prompts
-        if debug:
-            print("🔧 DEBUG: Using multi-chunk processing with Moby Dick-optimized prompts")
-
-        chunk_summaries = []
-        current_position = 0
-        step_number = 1
+            # Generic, context-aware user prompt
+            summarization_objective = contextual_prompt or "Create a comprehensive summary by extracting all key facts, concepts, and conclusions from the text."
+            scratchpad_status = "The analysis is just beginning; this is the first chunk." if not chunk_summaries else f"Building on existing analysis with {len(chunk_summaries)} sections already completed."
+
+            user_prompt = (
+                f"--- Global Objective ---\n{summarization_objective}\n\n"
+                f"--- Current Progress ---\n"
+                f"{scratchpad_status} (Step {step_number}/{total_estimated_steps})\n\n"
+                f"--- Existing Scratchpad Content (for context) ---\n{current_scratchpad}\n\n"
+                f"--- New Text Chunk to Analyze ---\n{chunk_text}\n\n"
+                f"--- Your Instructions ---\n"
+                f"Extract key information from the 'New Text Chunk' that aligns with the 'Global Objective'. "
+                f"Provide a concise summary of the new findings. Do not repeat what is already in the scratchpad. "
+                f"If no new relevant information is found, state that clearly."
+            )
 
-        while current_position < len(tokens):
-            # Recalculate budget
-            current_scratchpad = "\n\n---\n\n".join(chunk_summaries) if chunk_summaries else "[Empty]"
-            current_budget = calculate_token_budgets(current_scratchpad, step_number)
-            adaptive_chunk_size = max(400, current_budget["chunk_budget"])  # Increased minimum
+            if debug:
+                print(f"🔧 DEBUG: Sending {len(user_prompt)} char prompt to LLM")
 
-            # Extract chunk
-            chunk_end = min(current_position + adaptive_chunk_size, len(tokens))
-            chunk_tokens = tokens[current_position:chunk_end]
-            chunk_text = " ".join(chunk_tokens)
+            chunk_summary = self.remove_thinking_blocks(self.llm.generate_text(user_prompt, system_prompt=system_prompt, **kwargs))
 
             if debug:
-                print(f"\n🔧 DEBUG Step {step_number}: Processing chunk {current_position}:{chunk_end} "
-                      f"({len(chunk_tokens)} tokens, {len(chunk_text)} chars)")
-
-            # Progress calculation
-            remaining_tokens = len(tokens) - current_position
-            estimated_remaining_steps = max(1, remaining_tokens // adaptive_chunk_size)
-            total_estimated_steps = step_number + estimated_remaining_steps - 1
-            progress = (current_position / len(tokens)) * 90
+                print(f"🔧 DEBUG: Received {len(chunk_summary)} char response preview: {chunk_summary[:200]}...")
+
+            # Generic content filtering
+            filter_out = False
+            filter_reason = "content accepted"
+
+            # Check for explicit rejection signals
+            if (chunk_summary.strip().lower().startswith('[no new') or
+                chunk_summary.strip().lower().startswith('no new information')):
+                filter_out = True
+                filter_reason = "explicit rejection signal"
+            # Check for overly short or generic refusal responses
+            elif len(chunk_summary.strip()) < 25:
+                filter_out = True
+                filter_reason = "response too short to be useful"
+            # Check for common error phrases
+            elif any(error_phrase in chunk_summary.lower()[:150] for error_phrase in [
+                'error', 'failed', 'cannot provide', 'unable to analyze', 'not possible', 'insufficient information']):
+                filter_out = True
+                filter_reason = "error or refusal response detected"
+
+            if not filter_out:
+                chunk_summaries.append(chunk_summary.strip())
+                content_added = True
+                if debug:
+                    print(f"🔧 DEBUG: ✅ Content added to scratchpad (total sections: {len(chunk_summaries)})")
+            else:
+                content_added = False
+                if debug:
+                    print(f"🔧 DEBUG: ❌ Content filtered out - {filter_reason}: {chunk_summary[:100]}...")
 
+            # Update progress via callback
             if streaming_callback:
+                updated_scratchpad = "\n\n---\n\n".join(chunk_summaries)
                 streaming_callback(
-                    f"Processing chunk {step_number}/{total_estimated_steps} - "
-                    f"Budget: {adaptive_chunk_size:,} tokens",
-                    MSG_TYPE.MSG_TYPE_STEP_START,
-                    {"step": step_number, "progress": progress}
-                )
-
-            try:
-                # FIXED: Moby Dick-specific system prompt that prevents false filtering
-                system_prompt = (
-                    f"You are analyzing Herman Melville's \"Moby Dick\" - a complex literary work where EVERY passage contains literary value.\n\n"
-                    f"**Critical Understanding:**\n"
-                    f"- Melville's detailed descriptions of whaling culture ARE literary techniques\n"
-                    f"- Technical passages reveal themes about knowledge, obsession, and human industry\n"
-                    f"- Social customs and maritime protocols reflect broader themes of hierarchy and civilization\n"
-                    f"- Even seemingly mundane details contribute to Melville's encyclopedic narrative style\n\n"
-                    f"**Current Status:** Step {step_number} of ~{total_estimated_steps} | Progress: {progress:.1f}%\n\n"
-                    f"**Your Task:**\n"
-                    f"Extract literary insights from this text chunk, focusing on:\n"
-                    f"1. **Themes** (obsession, knowledge, nature vs civilization, social hierarchy)\n"
-                    f"2. **Narrative Technique** (Melville's encyclopedic style, detailed realism)\n"
-                    f"3. **Cultural Commentary** (maritime society, American industry, social structures)\n"
-                    f"4. **Character Insights** (authority, dignity, social roles)\n"
-                    f"5. **Symbolic Elements** (ships, sea, whaling practices as metaphors)\n\n"
-                    f"**CRITICAL:** The scratchpad shows '{current_scratchpad[:20]}...' - if it shows '[Empty]', you are analyzing early content and everything you find is 'new' information. "
-                    f"Do NOT say '[No new information]' unless the chunk is literally empty or corrupted.\n\n"
-                    f"Be specific and extract concrete insights. Melville's detailed realism IS his literary technique."
+                    updated_scratchpad,
+                    MSG_TYPE.MSG_TYPE_SCRATCHPAD,
+                    {"step": step_number, "sections": len(chunk_summaries), "content_added": content_added, "filter_reason": filter_reason}
                 )
-
-                # FIXED: Moby Dick-specific user prompt with clear instructions
-                summarization_objective = contextual_prompt or "Create comprehensive literary analysis of Moby-Dick focusing on themes, character development, narrative techniques, and symbolism"
-
-                # Determine scratchpad status for better context
-                scratchpad_status = "The analysis is just beginning - this is among the first substantial content to be processed." if current_scratchpad == "[Empty]" else f"Building on existing analysis with {len(chunk_summaries)} sections already completed."
-
-                user_prompt = (
-                    f"--- Global Objective ---\n{summarization_objective}\n\n"
-                    f"--- Current Progress ---\n"
-                    f"Step {step_number} of ~{total_estimated_steps} | Progress: {progress:.1f}% | Token Budget: {adaptive_chunk_size:,}\n\n"
-                    f"--- Current Analysis State ---\n{scratchpad_status}\n\n"
-                    f"--- Existing Scratchpad Content ---\n{current_scratchpad}\n\n"
-                    f"--- New Text Chunk from Moby Dick ---\n{chunk_text}\n\n"
-                    f"--- Analysis Instructions ---\n"
-                    f"This is Melville's \"Moby Dick\" - extract literary insights from this passage. Consider:\n\n"
-                    f"• **What themes** does this passage develop? (obsession with knowledge, social hierarchy, maritime culture)\n"
-                    f"• **What narrative techniques** does Melville use? (detailed realism, encyclopedic style, technical precision)\n"
-                    f"• **What cultural commentary** is present? (whaling society, American industry, social protocols)\n"
-                    f"• **What character insights** emerge? (authority, dignity, social roles and expectations)\n"
-                    f"• **What symbolic elements** appear? (ships, maritime customs, hierarchical structures)\n\n"
-                    f"**Remember:** In Moby Dick, even technical descriptions serve literary purposes. Melville's detailed realism and cultural documentation ARE his narrative techniques.\n\n"
-                    f"Provide specific, concrete analysis with examples from the text. Extract insights that are not already captured in the scratchpad above."
+                progress_after = ((current_position + len(chunk_tokens)) / len(tokens)) * 90 if len(tokens) > 0 else 90
+                streaming_callback(
+                    f"Step {step_number} completed - {'Content added' if content_added else f'Filtered: {filter_reason}'}",
+                    MSG_TYPE.MSG_TYPE_STEP_END,
+                    {"progress": progress_after}
                 )
 
-                if debug:
-                    print(f"🔧 DEBUG: Sending {len(user_prompt)} char prompt to LLM")
-                    print(f"🔧 DEBUG: Scratchpad status: {scratchpad_status}")
-
-                chunk_summary = self.remove_thinking_blocks(self.llm.generate_text(user_prompt, system_prompt=system_prompt, **kwargs))
-
-                if debug:
-                    print(f"🔧 DEBUG: Received {len(chunk_summary)} char response")
-                    print(f"🔧 DEBUG: Response preview: {chunk_summary[:200]}...")
-
-                # FIXED: More intelligent content filtering specifically for literary analysis
-                filter_out = False
-
-                # Check for explicit rejection signals
-                if (chunk_summary.strip().startswith('[No new insights]') or
-                    chunk_summary.strip().startswith('[No new information]') or 
-                    chunk_summary.strip().startswith('[No significant') or
-                    'cannot provide' in chunk_summary.lower()[:100] or
-                    'unable to analyze' in chunk_summary.lower()[:100]):
-                    filter_out = True
-                    filter_reason = "explicit rejection signal"
-
-                # Check for too short responses
-                elif len(chunk_summary.strip()) < 50:
-                    filter_out = True  
-                    filter_reason = "response too short"
-
-                # Check for error responses
-                elif any(error_phrase in chunk_summary.lower()[:150] for error_phrase in [
-                    'error', 'failed', 'cannot', 'unable', 'not possible', 'insufficient']):
-                    filter_out = True
-                    filter_reason = "error response detected"
-
-                else:
-                    filter_reason = "content accepted"
-
-                if not filter_out:
-                    chunk_summaries.append(chunk_summary.strip())
-                    content_added = True
-                    if debug:
-                        print(f"🔧 DEBUG: ✅ Content added to scratchpad (total sections: {len(chunk_summaries)})")
-                else:
-                    content_added = False
-                    if debug:
-                        print(f"🔧 DEBUG: ❌ Content filtered out - {filter_reason}: {chunk_summary[:100]}...")
-
-                # Update progress
-                if streaming_callback:
-                    updated_scratchpad = "\n\n---\n\n".join(chunk_summaries)
-                    streaming_callback(
-                        updated_scratchpad,
-                        MSG_TYPE.MSG_TYPE_SCRATCHPAD,
-                        {
-                            "step": step_number,
-                            "sections": len(chunk_summaries),
-                            "content_added": content_added,
-                            "filter_reason": filter_reason
-                        }
-                    )
-
-                progress_after = ((current_position + len(chunk_tokens)) / len(tokens)) * 90
-                if streaming_callback:
-                    streaming_callback(
-                        f"Step {step_number} completed - {'Content added' if content_added else f'Filtered: {filter_reason}'}",
-                        MSG_TYPE.MSG_TYPE_STEP_END,
-                        {"progress": progress_after}
-                    )
-
-            except Exception as e:
-                error_msg = f"Step {step_number} failed: {str(e)}"
-                if debug:
-                    print(f"🔧 DEBUG: ❌ {error_msg}")
-                self.trace_exception(e)
-                if streaming_callback:
-                    streaming_callback(error_msg, MSG_TYPE.MSG_TYPE_EXCEPTION)
-                chunk_summaries.append(f"[Error in step {step_number}: {str(e)[:100]}]")
-
-            # Move to next chunk
-            current_position += max(1, adaptive_chunk_size - overlap_tokens)
-            step_number += 1
-
-            # Safety break
-            if step_number > 50:
-                if debug:
-                    print(f"🔧 DEBUG: Breaking after {step_number-1} steps for safety")
-                break
-
-        if debug:
-            print(f"\n🔧 DEBUG: Completed chunking. Total sections: {len(chunk_summaries)}")
-
-        # Return scratchpad if requested
-        if return_scratchpad_only:
-            final_scratchpad = "\n\n---\n\n".join(chunk_summaries)
+        except Exception as e:
+            error_msg = f"Step {step_number} failed: {str(e)}"
+            if debug:
+                print(f"🔧 DEBUG: ❌ {error_msg}")
+            self.trace_exception(e)
             if streaming_callback:
-                streaming_callback("Returning scratchpad only", MSG_TYPE.MSG_TYPE_STEP, {})
-            return final_scratchpad.strip()
+                streaming_callback(error_msg, MSG_TYPE.MSG_TYPE_EXCEPTION)
+            chunk_summaries.append(f"[Error processing chunk at step {step_number}: {str(e)[:150]}]")
 
-        # Final synthesis
+        # Move to the next chunk, allowing for overlap
+        current_position += max(1, adaptive_chunk_size - overlap_tokens)
+        step_number += 1
+        
+        # Safety break for excessively long documents
+        if step_number > 200:
+            if debug: print(f"🔧 DEBUG: Safety break after {step_number-1} steps.")
+            chunk_summaries.append("[Processing halted due to exceeding maximum step limit.]")
+            break
+
+    if debug:
+        print(f"\n🔧 DEBUG: Chunk processing complete. Total sections gathered: {len(chunk_summaries)}")
+
+    # Return only the scratchpad content if requested
+    if return_scratchpad_only:
+        final_scratchpad = "\n\n---\n\n".join(chunk_summaries)
         if streaming_callback:
-            streaming_callback("Synthesizing final comprehensive analysis...", MSG_TYPE.MSG_TYPE_STEP_START, {"progress": 90})
-
-        if not chunk_summaries:
-            error_msg = "No content was successfully processed. The text may not contain recognizable literary elements, or there may be an issue with the processing."
-            if debug:
-                print(f"🔧 DEBUG: ❌ {error_msg}")
-            return error_msg
+            streaming_callback("Returning scratchpad content as final output.", MSG_TYPE.MSG_TYPE_STEP, {})
+        return final_scratchpad.strip()
 
-        combined_scratchpad = "\n\n---\n\n".join(chunk_summaries)
-        synthesis_objective = contextual_prompt or "Create comprehensive literary analysis of Moby-Dick."
+    # Final Synthesis Step
+    if streaming_callback:
+        streaming_callback("Synthesizing final comprehensive response...", MSG_TYPE.MSG_TYPE_STEP_START, {"progress": 95})
 
+    if not chunk_summaries:
+        error_msg = "No content was successfully processed or extracted from the document. The input might be empty or an issue occurred during processing."
         if debug:
-            print(f"🔧 DEBUG: Synthesizing from {len(combined_scratchpad):,} char scratchpad with {len(chunk_summaries)} sections")
-
-        # FIXED: Moby Dick-specific synthesis prompts
-        synthesis_system_prompt = (
-            "You are a literary analysis expert creating a final comprehensive analysis of Herman Melville's Moby Dick.\n"
-            "Synthesize all the insights from the analysis sections into a coherent, scholarly response.\n"
-            "Create clear sections with markdown headers, eliminate redundancy, and provide a thorough analysis.\n"
-            "Focus on Melville's major themes, narrative techniques, cultural commentary, and symbolic elements.\n"
-            "Use specific examples from the text and maintain academic rigor throughout."
-        )
+            print(f"🔧 DEBUG: ❌ {error_msg}")
+        return error_msg
+
+    combined_scratchpad = "\n\n---\n\n".join(chunk_summaries)
+    synthesis_objective = contextual_prompt or "Provide a comprehensive, well-structured summary and analysis of the provided text."
+
+    if debug:
+        print(f"🔧 DEBUG: Synthesizing from {len(combined_scratchpad):,} char scratchpad with {len(chunk_summaries)} sections.")
+
+    # Generic synthesis prompts
+    synthesis_system_prompt = (
+        "You are an expert AI assistant specializing in synthesizing information. "
+        "Your task is to consolidate a series of text analysis sections from a scratchpad into a single, coherent, and well-structured final response. "
+        "Eliminate redundancy, organize the content logically, and ensure the final output directly and comprehensively addresses the user's primary objective. "
+        "Use markdown for clear formatting (e.g., headers, lists, bold text)."
+    )
+
+    synthesis_user_prompt = (
+        f"--- Final Objective ---\n{synthesis_objective}\n\n"
+        f"--- Collected Analysis Sections (Scratchpad) ---\n{combined_scratchpad}\n\n"
+        f"--- Your Final Task ---\n"
+        f"Synthesize all the information from the 'Collected Analysis Sections' into a single, high-quality, and comprehensive response. "
+        f"Your response must directly address the 'Final Objective'. "
+        f"Organize your answer logically with clear sections using markdown headers. "
+        f"Ensure all key information is included, remove any repetitive statements, and produce a polished, final document."
+    )
+
+    try:
+        final_answer = self.remove_thinking_blocks(self.llm.generate_text(synthesis_user_prompt, system_prompt=synthesis_system_prompt, **kwargs))
+        if debug:
+            print(f"🔧 DEBUG: Final synthesis generated: {len(final_answer):,} characters")
+        if streaming_callback:
+            streaming_callback("Final synthesis complete.", MSG_TYPE.MSG_TYPE_STEP_END, {"progress": 100})
+        return final_answer.strip()
 
-        synthesis_user_prompt = (
-            f"--- Analysis Objective ---\n{synthesis_objective}\n\n"
-            f"--- Processing Summary ---\n"
-            f"Successfully analyzed {len(chunk_summaries)} sections of Moby Dick through incremental literary analysis.\n"
-            f"Total scratchpad content: {len(combined_scratchpad):,} characters of literary insights.\n\n"
-            f"--- Collected Literary Analysis Sections ---\n{combined_scratchpad}\n\n"
-            f"--- Final Synthesis Task ---\n"
-            f"Create a comprehensive, well-structured literary analysis of Moby Dick using ALL the insights above. "
-            f"Organize into clear sections with markdown headers (## Theme Analysis, ## Narrative Techniques, ## Cultural Commentary, ## Symbolism, etc.). "
-            f"Eliminate redundancy and create a coherent, scholarly analysis that demonstrates understanding of Melville's complex literary achievement. "
-            f"Include specific textual examples and maintain academic depth throughout."
+    except Exception as e:
+        error_msg = f"The final synthesis step failed: {str(e)}. Returning the organized scratchpad content as a fallback."
+        if debug: print(f"🔧 DEBUG: ❌ {error_msg}")
+        
+        # Fallback to returning the organized scratchpad
+        organized_scratchpad = (
+            f"# Analysis Summary\n\n"
+            f"*Note: The final synthesis process encountered an error. The raw, organized analysis sections are provided below.*\n\n"
+            f"## Collected Sections\n\n"
+            f"{combined_scratchpad}"
         )
-
-        try:
-            final_answer = self.remove_thinking_blocks(self.llm.generate_text(synthesis_user_prompt, system_prompt=synthesis_system_prompt, **kwargs)) 
-
-            if debug:
-                print(f"🔧 DEBUG: Final analysis: {len(final_answer):,} characters")
-
-            if streaming_callback:
-                streaming_callback(f"Final synthesis completed - {len(final_answer):,} characters generated", MSG_TYPE.MSG_TYPE_STEP_END, {"progress": 100})
-
-            return final_answer.strip()
-
-        except Exception as e:
-            error_msg = f"Synthesis failed: {str(e)}. Returning organized scratchpad content."
-            if debug:
-                print(f"🔧 DEBUG: ❌ {error_msg}")
-
-            # Return organized scratchpad as fallback
-            organized_scratchpad = (
-                f"# Literary Analysis of Moby Dick\n\n"
-                f"*Note: Synthesis process encountered issues, presenting organized analysis sections:*\n\n"
-                f"## Analysis Sections\n\n"
-                f"{combined_scratchpad}"
-            )
-            return organized_scratchpad
+        return organized_scratchpad
         
 
 def chunk_text(text, tokenizer, detokenizer, chunk_size, overlap, use_separators=True):

lollms_client/tti_bindings/diffusers/__init__.py

@@ -35,7 +35,8 @@ try:
         AutoPipelineForInpainting,
         DiffusionPipeline,
         StableDiffusionPipeline,
-        
+        QwenImageEditPipeline,
+        QwenImageEditPlusPipeline
     )
     from diffusers.utils import load_image
     from PIL import Image
@@ -47,6 +48,8 @@ except ImportError:
     AutoPipelineForInpainting = None
     DiffusionPipeline = None
     StableDiffusionPipeline = None
+    QwenImageEditPipeline = None
+    QwenImageEditPlusPipeline = None
     Image = None
     load_image = None
     DIFFUSERS_AVAILABLE = False
@@ -359,7 +362,12 @@ class ModelManager:
                     common_args["safety_checker"] = None
                 if self.config.get("hf_cache_path"):
                     common_args["cache_dir"] = str(self.config["hf_cache_path"])
-                if task == "text2image":
+
+                if "Qwen-Image-Edit-2509" in str(model_path):
+                    self.pipeline = QwenImageEditPlusPipeline.from_pretrained(model_path, **common_args)
+                elif "Qwen-Image-Edit" in str(model_path):
+                    self.pipeline = QwenImageEditPipeline.from_pretrained(model_path, **common_args)
+                elif task == "text2image":
                     self.pipeline = AutoPipelineForText2Image.from_pretrained(model_path, **common_args)
                 elif task == "image2image":
                     self.pipeline = AutoPipelineForImage2Image.from_pretrained(model_path, **common_args)
@@ -498,9 +506,10 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
         {"family": "SD 1.x", "model_name": "runwayml/stable-diffusion-v1-5", "display_name": "Stable Diffusion 1.5", "desc": "Classic SD1.5."},
         {"family": "SD 2.x", "model_name": "stabilityai/stable-diffusion-2-1", "display_name": "Stable Diffusion 2.1", "desc": "SD2.1 base."},
         {"family": "SD3", "model_name": "stabilityai/stable-diffusion-3-medium-diffusers", "display_name": "Stable Diffusion 3 Medium", "desc": "SD3 medium."},
-        {"family": "Qwen", "model_name": "Qwen/Qwen-Image", "display_name": "Qwen Image Edit", "desc": "Dedicated image generation."},
+        {"family": "Qwen", "model_name": "Qwen/Qwen-Image", "display_name": "Qwen Image", "desc": "Dedicated image generation."},
         {"family": "Specialized", "model_name": "playgroundai/playground-v2.5-1024px-aesthetic", "display_name": "Playground v2.5", "desc": "High aesthetic 1024."},
-        {"family": "Editors", "model_name": "Qwen/Qwen-Image-Edit", "display_name": "Qwen Image Edit", "desc": "Dedicated image editing."}
+        {"family": "Editors", "model_name": "Qwen/Qwen-Image-Edit", "display_name": "Qwen Image Edit", "desc": "Dedicated image editing."},
+        {"family": "Editors", "model_name": "Qwen/Qwen-Image-Edit-2509", "display_name": "Qwen Image Edit Plus (Multi-Image)", "desc": "Advanced multi-image editing, fusion, and pose transfer."}
     ]
 
     def __init__(self, **kwargs):
@@ -679,6 +688,25 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
         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"])
+
+        # Handle multi-image fusion for Qwen-Image-Edit-2509
+        if "Qwen-Image-Edit-2509" in self.model_name and len(pil_images) > 1:
+            pipeline_args = {
+                "image": pil_images,
+                "prompt": prompt,
+                "negative_prompt": negative_prompt or " ",
+                "width": out_w, "height": out_h,
+                "num_inference_steps": steps,
+                "true_cfg_scale": guidance,
+                "generator": generator
+            }
+            pipeline_args.update(kwargs)
+            future = Future()
+            self.manager.queue.put((future, "image2image", pipeline_args))
+            ASCIIColors.info(f"Job (multi-image fusion with {len(pil_images)} images) queued.")
+            return future.result()
+
+        # Handle inpainting (single image with mask)
         if mask is not None and len(pil_images) == 1:
             try:
                 mask_img = self._decode_image_input(mask).convert("L")
@@ -689,36 +717,46 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
                 "mask_image": mask_img,
                 "prompt": prompt,
                 "negative_prompt": negative_prompt or None,
-                "width": out_w,
-                "height": out_h,
+                "width": out_w, "height": out_h,
                 "num_inference_steps": steps,
                 "guidance_scale": guidance,
                 "generator": generator
             }
             pipeline_args.update(kwargs)
+            if "Qwen-Image-Edit" in self.model_name:
+                pipeline_args["true_cfg_scale"] = pipeline_args.pop("guidance_scale", 7.0)
+                if not pipeline_args.get("negative_prompt"): pipeline_args["negative_prompt"] = " "
+
             future = Future()
             self.manager.queue.put((future, "inpainting", pipeline_args))
             ASCIIColors.info("Job (inpaint) queued.")
             return future.result()
+
+        # Handle standard image-to-image (single image)
         try:
             pipeline_args = {
-                "image": pil_images if len(pil_images) > 1 else pil_images[0],
+                "image": pil_images[0],
                 "prompt": prompt,
                 "negative_prompt": negative_prompt or None,
                 "strength": kwargs.pop("strength", 0.6),
-                "width": out_w,
-                "height": out_h,
+                "width": out_w, "height": out_h,
                 "num_inference_steps": steps,
                 "guidance_scale": guidance,
                 "generator": generator
             }
             pipeline_args.update(kwargs)
+            if "Qwen-Image-Edit" in self.model_name:
+                pipeline_args["true_cfg_scale"] = pipeline_args.pop("guidance_scale", 7.0)
+                if not pipeline_args.get("negative_prompt"): pipeline_args["negative_prompt"] = " "
+
             future = Future()
             self.manager.queue.put((future, "image2image", pipeline_args))
             ASCIIColors.info("Job (i2i) queued.")
             return future.result()
         except Exception:
             pass
+
+        # Fallback to latent-based generation if i2i fails for some reason
         try:
             base = pil_images[0]
             latents, _ = self._encode_image_to_latents(base, out_w, out_h)
@@ -729,8 +767,7 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
                 "num_inference_steps": steps,
                 "guidance_scale": guidance,
                 "generator": generator,
-                "width": out_w,
-                "height": out_h
+                "width": out_w, "height": out_h
             }
             pipeline_args.update(kwargs)
             future = Future()
@@ -740,6 +777,7 @@ class DiffusersTTIBinding_Impl(LollmsTTIBinding):
         except Exception as e:
             raise Exception(f"Image edit failed: {e}") from e
 
+
     def list_local_models(self) -> List[str]:
         if not self.models_path.exists():
             return []
@@ -846,4 +884,4 @@ if __name__ == '__main__':
         ASCIIColors.cyan("\nCleaning up temporary directories...")
         if temp_paths_dir.exists():
             shutil.rmtree(temp_paths_dir)
-        ASCIIColors.magenta("--- Diffusers TTI Binding Test Finished ---")
+        ASCIIColors.magenta("--- Diffusers TTI Binding Test Finished ---")

{lollms_client-1.5.8.dist-info → lollms_client-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 1.5.8
+Version: 1.6.0
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License:                                  Apache License
@@ -249,7 +249,8 @@ Whether you're connecting to a remote LoLLMs server, an Ollama instance, the Ope
 ## Key Features
 
 *   🔌 **Versatile Binding System:** Seamlessly switch between different LLM backends (LoLLMs, Ollama, OpenAI, Llama.cpp, Transformers, vLLM, OpenLLM, Gemini, Claude, Groq, OpenRouter, Hugging Face Inference API) using a unified `llm_binding_config` dictionary for all parameters.
-*   🗣️ **Multimodal Support:** Interact with models capable of processing images and generate various outputs like speech (TTS), images (TTI), video (TTV), and music (TTM).
+*   🗣️ **Comprehensive Multimodal Support:** Interact with models capable of processing images and generate various outputs like speech (TTS), video (TTV), and music (TTM).
+*   🎨 **Advanced Image Generation and Editing:** A new `diffusers` binding provides powerful text-to-image capabilities. It supports a wide range of models from Hugging Face and Civitai, including specialized models like `Qwen-Image-Edit` for single-image editing and the cutting-edge `Qwen-Image-Edit-2509` for **multi-image fusion, pose transfer, and character swapping**.
 *   🖼️ **Selective Image Activation:** Control which images in a message are active and sent to the model, allowing for fine-grained multimodal context management without deleting the original data.
 *   🤖 **Agentic Workflows with MCP:** Empower LLMs to act as sophisticated agents, breaking down complex tasks, selecting and executing external tools (e.g., internet search, code interpreter, file I/O, image generation) through the Model Context Protocol (MCP) using a robust "observe-think-act" loop.
 *   🎭 **Personalities as Agents:** Personalities can now define their own set of required tools (MCPs) and have access to static or dynamic knowledge bases (`data_source`), turning them into self-contained, ready-to-use agents.
@@ -1300,9 +1301,110 @@ try:
 
 except Exception as e:
     ASCIIColors.error(f"Error initializing Hugging Face Inference API binding: {e}")
-    ASCIIColors.info("Please ensure your Hugging Face API token is correctly set and you have access to the specified model.")
+    ASCIIColors.info("Please ensure your Hugging Face API token is correctly set and you have access to the specified model.")```
+
+---
+
+### 4. Local Multimodal and Advanced Bindings
+
+#### **Diffusers (Local Text-to-Image Generation and Editing)**
+
+The `diffusers` binding leverages the Hugging Face `diffusers` library to run a vast array of text-to-image models locally on your own hardware (CPU or GPU). It supports models from Hugging Face and Civitai, providing everything from basic image generation to advanced, state-of-the-art image editing.
+
+**Prerequisites:**
+*   `torch` and `torchvision` must be installed. For GPU acceleration, it's critical to install the version that matches your CUDA toolkit.
+*   The binding will attempt to auto-install other requirements like `diffusers`, `transformers`, and `safetensors`.
+
+**Usage:**
+
+**Example 1: Basic Text-to-Image Generation**
+This example shows how to generate an image from a simple text prompt using a classic Stable Diffusion model.
+
+```python
+from lollms_client import LollmsClient
+from ascii_colors import ASCIIColors
+from pathlib import Path
+
+try:
+    # Initialize the client with the diffusers TTI binding
+    # Let's use a classic Stable Diffusion model for this example
+    lc = LollmsClient(
+        tti_binding_name="diffusers",
+        tti_binding_config={
+            "model_name": "runwayml/stable-diffusion-v1-5",
+            # Other options: "device", "torch_dtype_str", "enable_xformers"
+        }
+    )
+
+    prompt = "A high-quality photograph of an astronaut riding a horse on Mars."
+    ASCIIColors.yellow(f"Generating image for prompt: '{prompt}'")
+
+    # Generate the image. The result is returned as bytes.
+    image_bytes = lc.generate_image(prompt, width=512, height=512)
+
+    if image_bytes:
+        output_path = Path("./astronaut_on_mars.png")
+        with open(output_path, "wb") as f:
+            f.write(image_bytes)
+        ASCIIColors.green(f"Image saved successfully to: {output_path.resolve()}")
+    else:
+        ASCIIColors.error("Image generation failed.")
+
+except Exception as e:
+    ASCIIColors.error(f"An error occurred with the Diffusers binding: {e}")
+    ASCIIColors.info("Please ensure torch is installed correctly for your hardware (CPU/GPU).")
 ```
 
+**Example 2: Advanced Multi-Image Fusion with Qwen-Image-Edit-2509**
+This example demonstrates a cutting-edge capability: using a specialized model to fuse elements from multiple input images based on a text prompt. Here, we'll ask the model to take a person from one image and place them in the background of another.
+
+```python
+from lollms_client import LollmsClient
+from ascii_colors import ASCIIColors
+from pathlib import Path
+
+# --- IMPORTANT ---
+# Replace these with actual paths to your local images
+path_to_person_image = "./path/to/your/person.jpg"
+path_to_background_image = "./path/to/your/background.jpg"
+
+if not Path(path_to_person_image).exists() or not Path(path_to_background_image).exists():
+    ASCIIColors.warning("Input images not found. Skipping multi-image fusion example.")
+    ASCIIColors.warning(f"Please update 'path_to_person_image' and 'path_to_background_image'.")
+else:
+    try:
+        # Initialize with the advanced Qwen multi-image editing model
+        lc = LollmsClient(
+            tti_binding_name="diffusers",
+            tti_binding_config={
+                "model_name": "Qwen/Qwen-Image-Edit-2509",
+                "torch_dtype_str": "bfloat16" # Recommended for this model
+            }
+        )
+
+        # The prompt guides how the images are combined
+        prompt = "Place the person from the first image into the scenic background of the second image."
+        ASCIIColors.yellow(f"Fusing images with prompt: '{prompt}'")
+
+        # The edit_image method can accept a list of image paths for fusion
+        fused_image_bytes = lc.edit_image(
+            images=[path_to_person_image, path_to_background_image],
+            prompt=prompt,
+            num_inference_steps=50
+        )
+
+        if fused_image_bytes:
+            output_path = Path("./fused_image_result.png")
+            with open(output_path, "wb") as f:
+                f.write(fused_image_bytes)
+            ASCIIColors.green(f"Fused image saved successfully to: {output_path.resolve()}")
+        else:
+            ASCIIColors.error("Multi-image editing failed.")
+
+    except Exception as e:
+        ASCIIColors.error(f"An error occurred during multi-image fusion: {e}")
+```This powerful feature allows for complex creative tasks like character swapping, background replacement, and style transfer directly through the `lollms_client` library.
+
 ### Listing Available Models
 
 You can query the active LLM binding to get a list of models it supports or has available. The exact information returned depends on the binding (e.g., Ollama lists local models, OpenAI lists all its API models).

{lollms_client-1.5.8.dist-info → lollms_client-1.6.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-lollms_client/__init__.py,sha256=LmAWm88VN_dcmwMvHFYF3nl_p7TqW2D6oI1xjWmhXJ0,1146
+lollms_client/__init__.py,sha256=xI7gZKUDt8hWzRJuATINMJMA2w0uYLBf202yS1o2diY,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=Gc2KMyxnKWti-ljI7rf3XDb6a7NM2RUpktN8VnlWcyk,323791
+lollms_client/lollms_core.py,sha256=M-zLRrGlG_cFIExxRcMVN8tADFyp-y6L7mO9VKJDTwI,320416
 lollms_client/lollms_discussion.py,sha256=LZc9jYbUMRTovehiFJKEp-NXuCl_WnrqUtT3t4Nzayk,123922
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
 lollms_client/lollms_llm_binding.py,sha256=tXuc3gxe6UrP36OBGsR-ESvQ9LpsB_nqtqL-GsEj6Uc,25019
@@ -52,7 +52,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=3ANfQ3WtOpyMmxdfQDX4mteupZ6sLFlE-GVj-Qi-FVI,41849
+lollms_client/tti_bindings/diffusers/__init__.py,sha256=IB4yZpYOY7bq9l1rRNM9SZzy5EbKqGsY2BlEY3hX_Pg,43892
 lollms_client/tti_bindings/gemini/__init__.py,sha256=f9fPuqnrBZ1Z-obcoP6EVvbEXNbNCSg21cd5efLCk8U,16707
 lollms_client/tti_bindings/leonardo_ai/__init__.py,sha256=EvjKyV8kM7-tmLwC1agSQ-v7thrNgflrmFxhDLqzT8U,5884
 lollms_client/tti_bindings/lollms/__init__.py,sha256=5Tnsn4b17djvieQkcjtIDBm3qf0pg5ZWWov-4_2wmo0,8762
@@ -80,8 +80,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.5.8.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-1.5.8.dist-info/METADATA,sha256=EMkJabEuQ0JcBVg7KkQQzfTvrWO65N4-44qM8uEW4kQ,71861
-lollms_client-1.5.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-1.5.8.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
-lollms_client-1.5.8.dist-info/RECORD,,
+lollms_client-1.6.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-1.6.0.dist-info/METADATA,sha256=OmxnZ9K0GlxOGVMyiuxKF0TkSfCCDWGvQ8nuVGBbJO0,76825
+lollms_client-1.6.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-1.6.0.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
+lollms_client-1.6.0.dist-info/RECORD,,