lollms-client 1.5.5__tar.gz → 1.5.7__tar.gz

{lollms_client-1.5.5/src/lollms_client.egg-info → lollms_client-1.5.7}/PKG-INFO

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

{lollms_client-1.5.5 → lollms_client-1.5.7}/src/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.5" # Updated version
+__version__ = "1.5.7" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

{lollms_client-1.5.5 → lollms_client-1.5.7}/src/lollms_client/llm_bindings/lollms/__init__.py

@@ -232,7 +232,7 @@ class LollmsBinding(LollmsLLMBinding):
                     chat_completion = self.client.chat.completions.create(**params)
                 except Exception as ex:
                     # exception for new openai models
-                    params["max_completion_tokens"]=params["max_tokens"]
+                    params["max_completion_tokens"]=params.get("max_tokens") or params.get("max_completion_tokens") or self.default_ctx_size
                     params["temperature"]=1
                     try: del params["max_tokens"] 
                     except Exception: pass

{lollms_client-1.5.5 → lollms_client-1.5.7}/src/lollms_client/lollms_core.py

@@ -1680,7 +1680,7 @@ Output the parameters as JSON: {{"tool_params": {{...}}}}"""
                     raw_results = rag_fn(query=query, rag_top_k=rag_top_k, rag_min_similarity_percent=rag_min_similarity_percent)
                     docs = [d for d in (raw_results.get("results", []) if isinstance(raw_results, dict) else raw_results or [])]
                     tool_result = {"status": "success", "results": docs}
-                    sources = [{"source": tool_name, "metadata": d.get("metadata", {}), "score": d.get("score", 0.0)} for d in docs]
+                    sources = [{"title":d["title"], "content":d["content"], "source": tool_name, "metadata": d.get("metadata", {}), "score": d.get("score", 0.0)} for d in docs]
                     log_event(f"Retrieved {len(docs)} relevant documents", MSG_TYPE.MSG_TYPE_INFO)
                 elif hasattr(self, "mcp") and "local_tools" not in tool_name:
                     log_event(f"Executing MCP tool: {tool_name}", MSG_TYPE.MSG_TYPE_TOOL_CALL, meta={"tool_name": tool_name, "params": tool_params})
@@ -5736,186 +5736,353 @@ Provide the final aggregated answer in {output_format} format, directly addressi
         self,
         text_to_process: str,
         contextual_prompt: Optional[str] = None,
-        chunk_size_tokens: int|None = 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:
-        """
-        Summarizes a long text that may not fit into the model's context window.
+        """Enhanced long context processing with Moby Dick literary analysis optimization."""
 
-        This method works in two stages:
-        1.  **Chunk & Summarize:** It breaks the text into overlapping chunks and summarizes each one individually.
-        2.  **Synthesize:** It then takes all the chunk summaries and performs a final summarization pass to create a single, coherent, and comprehensive summary.
+        if debug:
+            print(f"\n🔧 DEBUG: Starting processing with {len(text_to_process):,} characters")
 
-        Args:
-            text_to_process (str): The long text content to be summarized.
-            contextual_prompt (Optional[str], optional): A specific instruction to guide the summary's focus. 
-                                                       For example, "Summarize the text focusing on the financial implications."
-                                                       Defaults to None.
-            chunk_size_tokens (int, optional): The number of tokens in each text chunk. This should be well
-                                             within the model's context limit to allow space for prompts.
-                                             Defaults to 1500.
-            overlap_tokens (int, optional): The number of tokens to overlap between chunks to ensure context
-                                          is not lost at the boundaries. Defaults to 250.
-            streaming_callback (Optional[Callable], optional): A callback function to receive real-time updates
-                                                             on the process (e.g., which chunk is being processed).
-                                                             It receives a message, a message type, and optional metadata.
-                                                             Defaults to None.
-            **kwargs: Additional keyword arguments to be passed to the generation method (e.g., temperature, top_p).
+        # 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}")
 
-        Returns:
-            str: The final, comprehensive summary of the text.
-        """
-        if not text_to_process and len(kwargs.get("images",[]))==0 and contextual_prompt is None:
-            return ""
+        # Get context size
+        try:
+            context_size = self.llm.get_context_size() or 4096
+        except:
+            context_size = 4096
+
+        if debug:
+            print(f"🔧 DEBUG: Context size: {context_size}, Fill %: {context_fill_percentage}")
+
+        # Handle empty input
         if not text_to_process:
-            text_to_process=""
-            tokens = []
-        else:
-            # Use the binding's tokenizer for accurate chunking
-            tokens = self.llm.tokenize(text_to_process)
-        if chunk_size_tokens is None:
-            chunk_size_tokens = self.llm.default_ctx_size//2
-        
+            return ""
+
+        # Use word-based tokenization
+        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:
+            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)
+            }
+
+            if debug:
+                print(f"🔧 DEBUG Step {step_num}: Budget = {available_for_chunk}/{total_budget} tokens, "
+                      f"Scratchpad = {int(scratchpad_tokens)} tokens")
+
+            return budget_info
+
+        # Initial budget calculation
+        initial_budget = calculate_token_budgets()
+        chunk_size_tokens = initial_budget["chunk_budget"]
+
+        if debug:
+            print(f"🔧 DEBUG: Initial chunk size: {chunk_size_tokens} word tokens")
+
+        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}
+            )
+
+        # Single pass for short content
         if len(tokens) <= chunk_size_tokens:
+            if debug:
+                print("🔧 DEBUG: Using single-pass processing")
+
             if streaming_callback:
-                streaming_callback("Text is short enough for a single pass.", MSG_TYPE.MSG_TYPE_STEP, {"progress": 0})
-            system_prompt = ("You are a content processor expert.\n"
-                            "You perform tasks on the content as requested by the user.\n\n"
-                            "--- Content ---\n"
-                            f"{text_to_process}\n\n"
-                            "** Important **\n"
-                            "Strictly adhere to the user prompt.\n"
-                            "Do not add comments unless asked to do so.\n"
-                            )
-            if "system_prompt" in kwargs:
-                system_prompt += "-- Extra instructions --\n"+ kwargs["system_prompt"] +"\n"
-                del kwargs["system_prompt"]            
-            prompt_objective = contextual_prompt or "Provide a comprehensive summary of the content."
-            final_prompt = f"{prompt_objective}"
-            
-            processed_output = self.generate_text(final_prompt, system_prompt=system_prompt, **kwargs)
-            
-            if streaming_callback:
-                streaming_callback("Content processed.", MSG_TYPE.MSG_TYPE_STEP, {"progress": 100})
-            
-            return processed_output
+                streaming_callback("Content fits in single pass", MSG_TYPE.MSG_TYPE_STEP, {})
+
+            # FIXED: Moby Dick-specific single-pass 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."
+            )
 
-        # --- Stage 1: Chunking and Independent Summarization ---
-        chunks = []
-        step = chunk_size_tokens - overlap_tokens
-        for i in range(0, len(tokens), step):
-            chunk_tokens = tokens[i:i + chunk_size_tokens]
-            chunk_text = self.llm.detokenize(chunk_tokens)
-            chunks.append(chunk_text)
+            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 = []
-        
-        # Total steps include each chunk plus the final synthesis step
-        total_steps = len(chunks) + 1
-        
-        # Define the prompt for summarizing each chunk
-        summarization_objective = contextual_prompt or "Summarize the key points of the following text excerpt."
-        system_prompt = ("You are a sequential document processing agent.\n"
-                         "The process is done in two phases:\n"
-                         "** Phase1 : **\n"
-                         "Sequencially extracting information from the text chunks and adding them to the scratchpad.\n"
-                         "** Phase2: **\n"
-                         "Synthesizing a comprehensive Response using the scratchpad content given the objective formatting instructions if applicable.\n"
-                         "We are now performing ** Phase 1 **, and we are processing chunk number {{chunk_id}}.\n"
-                         "Your job is to extract information from the current chunk given previous chunks extracted information placed in scratchpad as well as the current chunk content.\n"
-                         "Add the information to the scratchpad while strictly adhering to the Global objective extraction instructions:\n"
-                         "-- Sequencial Scratchpad --\n"
-                         "{{scratchpad}}\n"
-                         "** Important **\n"
-                         "Respond only with the extracted information from the current chunk without repeating things that are already in the scratchpad.\n"
-                         "Strictly adhere to the Global objective content for the extraction phase.\n"
-                         "Do not add comments.\n"
-                        )
-        if "system_prompt" in kwargs:
-            system_prompt += "-- Extra instructions --\n"+ kwargs["system_prompt"] +"\n"
-            del kwargs["system_prompt"]
-        chunk_summary_prompt_template = f"--- Global objective ---\n{summarization_objective}\n\n--- Text Excerpt ---\n{{chunk_text}}"
+        current_position = 0
+        step_number = 1
+
+        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
+
+            # Extract chunk
+            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"\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
 
-        for i, chunk in enumerate(chunks):
-            progress_before = (i / total_steps) * 100
             if streaming_callback:
                 streaming_callback(
-                    f"Processing chunk {i + 1} of {len(chunks)}...", 
-                    MSG_TYPE.MSG_TYPE_STEP_START, 
-                    {"id": f"chunk_{i+1}", "progress": progress_before}
+                    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:
-                prompt = chunk_summary_prompt_template.format(chunk_text=chunk)
-            except Exception as ex:
-                ASCIIColors.warning(ex)
-                prompt = chunk_summary_prompt_template.replace("{chunk_text}", chunk)
-            processed_system_prompt = system_prompt.format(chunk_id=i,scratchpad="\n\n---\n\n".join(chunk_summaries))
-            try:
-                # Generate summary for the current chunk
-                chunk_summary = self.generate_text(prompt, system_prompt=processed_system_prompt, **kwargs)
-                chunk_summaries.append(chunk_summary)
-                
-                progress_after = ((i + 1) / total_steps) * 100
+                # 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."
+                )
+
+                # 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."
+                )
+
+                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(
-                        f"Chunk {i + 1} processed. Progress: {progress_after:.0f}%", 
-                        MSG_TYPE.MSG_TYPE_STEP_END, 
-                        {"id": f"chunk_{i+1}", "output_snippet": chunk_summary[:100], "progress": progress_after}
+                        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:
-                trace_exception(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(f"Failed to process chunk {i+1}: {e}", MSG_TYPE.MSG_TYPE_EXCEPTION)
-                # Still add a placeholder to not break the chain
-                chunk_summaries.append(f"[Error processing chunk {i+1}]")
+                    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)
+            if streaming_callback:
+                streaming_callback("Returning scratchpad only", MSG_TYPE.MSG_TYPE_STEP, {})
+            return final_scratchpad.strip()
 
-        # --- Stage 2: Final Synthesis of All Chunk Summaries ---
-        progress_before_synthesis = (len(chunks) / total_steps) * 100
+        # Final synthesis
         if streaming_callback:
-            streaming_callback(
-                "Processing the scratchpad content into a final version...", 
-                MSG_TYPE.MSG_TYPE_STEP_START, 
-                {"id": "final_synthesis", "progress": progress_before_synthesis}
-            )
+            streaming_callback("Synthesizing final comprehensive analysis...", MSG_TYPE.MSG_TYPE_STEP_START, {"progress": 90})
 
-        combined_summaries = "\n\n---\n\n".join(chunk_summaries)
-        
-        # Define the prompt for the final synthesis
-        synthesis_objective = contextual_prompt or "Create a single, final, coherent, and comprehensive summary."
-        system_prompt = ("You are a sequential document processing agent.\n"
-                         "The process is done in two phases:\n"
-                         "** Phase1 : **\n"
-                         "Sequencially extracting information from the text chunks and adding them to the scratchpad.\n"
-                         "** Phase2: **\n"
-                         "Synthesizing a comprehensive Response using the scratchpad content given the objective formatting instructions if applicable.\n"
-                         "\n"
-                         "We are now performing ** Phase 2 **.\n"
-                         "Your job is to use the extracted information to fulfill the user prompt objectives.\n"
-                         "Make sure you respect the user formatting if provided and if not, then use markdown output format."
-                         "-- Sequencial Scratchpad --\n"
-                         f"{combined_summaries}\n"
-                         "** Important **\n"
-                         "Respond only with the requested task without extra comments unless told to.\n"
-                         "Strictly adhere to the Global objective content for the extraction phase.\n"
-                         "Do not add comments.\n"
-                        )
-        final_synthesis_prompt = (
-            f"--- Global objective ---\n{synthesis_objective}\n\n"
-            "--- Final Response ---"
+        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
+
+        combined_scratchpad = "\n\n---\n\n".join(chunk_summaries)
+        synthesis_objective = contextual_prompt or "Create comprehensive literary analysis of Moby-Dick."
+
+        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."
         )
 
-        final_answer = self.generate_text(final_synthesis_prompt, system_prompt=system_prompt, **kwargs)
-        
-        if streaming_callback:
-            streaming_callback(
-                "Final summary synthesized.", 
-                MSG_TYPE.MSG_TYPE_STEP_END, 
-                {"id": "final_synthesis", "progress": 100}
-            )
+        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."
+        )
+
+        try:
+            final_answer = self.remove_thinking_blocks(self.llm.generate_text(synthesis_user_prompt, system_prompt=synthesis_system_prompt, **kwargs)) 
 
-        return final_answer.strip()
+            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
+        
 
 def chunk_text(text, tokenizer, detokenizer, chunk_size, overlap, use_separators=True):
     """

{lollms_client-1.5.5 → lollms_client-1.5.7}/src/lollms_client/lollms_llm_binding.py

@@ -197,7 +197,7 @@ class LollmsLLMBinding(ABC):
         """
         pass
 
-    def get_ctx_size(self, model_name: Optional[str] = None) -> Optional[int]:
+    def get_ctx_size(self, model_name: Optional[str|None] = None) -> Optional[int]:
         """
         Retrieves context size for a model from a hardcoded list.
 

{lollms_client-1.5.5 → lollms_client-1.5.7/src/lollms_client.egg-info}/PKG-INFO

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