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

lollms_client/lollms_agentic.py

@@ -65,19 +65,21 @@ class TaskPlanner:
     def __init__(self, llm_client):
         self.llm_client = llm_client
         
-    def decompose_task(self, user_request: str, context: str = "") -> ExecutionPlan:
+    def decompose_task(self, user_request: str, context: str = "", all_visible_tools:str="") -> ExecutionPlan:
         """Break down complex requests into manageable subtasks"""
         decomposition_prompt = f"""
 Analyze this user request and break it down into specific, actionable subtasks:
 
 USER REQUEST: "{user_request}"
 CONTEXT: {context}
+AVAILABLE TOOLS: {all_visible_tools}
 
 Create a JSON plan with subtasks that are:
 1. Specific and actionable
 2. Have clear success criteria  
 3. Include estimated complexity (1-5 scale)
 4. List required tool types
+5. The tasks should either be thought based, or use one of the available tools. Do not plan tasks we can not do.
 
 Output format:
 {{
@@ -358,4 +360,4 @@ class UncertaintyManager:
         else:
             level = ConfidenceLevel.LOW
             
-        return confidence, level
+        return confidence, level

lollms_client/lollms_core.py

@@ -91,21 +91,6 @@ class LollmsClient():
             stt_binding_config (Optional[Dict]): Additional config for the STT binding.
             ttv_binding_config (Optional[Dict]): Additional config for the TTV binding.
             ttm_binding_config (Optional[Dict]): Additional config for the TTM binding.
-            service_key (Optional[str]): Shared authentication key or client_id.
-            verify_ssl_certificate (bool): Whether to verify SSL certificates.
-            ctx_size (Optional[int]): Default context size for LLM.
-            n_predict (Optional[int]): Default max tokens for LLM.
-            stream (bool): Default streaming mode for LLM.
-            temperature (float): Default temperature for LLM.
-            top_k (int): Default top_k for LLM.
-            top_p (float): Default top_p for LLM.
-            repeat_penalty (float): Default repeat penalty for LLM.
-            repeat_last_n (int): Default repeat last n for LLM.
-            seed (Optional[int]): Default seed for LLM.
-            n_threads (int): Default threads for LLM.
-            streaming_callback (Optional[Callable]): Default streaming callback for LLM.
-            user_name (str): Default user name for prompts.
-            ai_name (str): Default AI name for prompts.
 
         Raises:
             ValueError: If the primary LLM binding cannot be created.
@@ -160,93 +145,119 @@ class LollmsClient():
             except Exception as e:
                 trace_exception(e)
                 ASCIIColors.warning(f"Exception occurred while creating TTS binding: {str(e)}")
+                self.tts = None
 
         if tti_binding_name:
-            if tti_binding_config:
-                self.tti = self.tti_binding_manager.create_binding(
-                    binding_name=tti_binding_name,
-                    **{
-                        k: v
-                        for k, v in (tti_binding_config or {}).items()
-                        if k != "binding_name"
-                    }
-                )
-            else:
-                self.tti = self.tti_binding_manager.create_binding(
-                    binding_name=tti_binding_name
-                )
-            if self.tti is None:
-                ASCIIColors.warning(f"Failed to create TTI binding: {tti_binding_name}. Available: {self.tti_binding_manager.get_available_bindings()}")
-
+            try:
+                if tti_binding_config:
+                    self.tti = self.tti_binding_manager.create_binding(
+                        binding_name=tti_binding_name,
+                        **{
+                            k: v
+                            for k, v in (tti_binding_config or {}).items()
+                            if k != "binding_name"
+                        }
+                    )
+                else:
+                    self.tti = self.tti_binding_manager.create_binding(
+                        binding_name=tti_binding_name
+                    )
+                if self.tti is None:
+                    ASCIIColors.warning(f"Failed to create TTI binding: {tti_binding_name}. Available: {self.tti_binding_manager.get_available_bindings()}")
+            except Exception as e:
+                trace_exception(e)
+                ASCIIColors.warning(f"Exception occurred while creating TTI binding: {str(e)}")
+                self.tti = None
+                
         if stt_binding_name:
-            if stt_binding_config:
-                self.stt = self.stt_binding_manager.create_binding(
-                    binding_name=stt_binding_name,
-                    **{
-                        k: v
-                        for k, v in (stt_binding_config or {}).items()
-                        if k != "binding_name"
-                    }
-                )
+            try:
+                if stt_binding_config:
+                    self.stt = self.stt_binding_manager.create_binding(
+                        binding_name=stt_binding_name,
+                        **{
+                            k: v
+                            for k, v in (stt_binding_config or {}).items()
+                            if k != "binding_name"
+                        }
+                    )
 
-            else:
-                self.stt = self.stt_binding_manager.create_binding(
-                    binding_name=stt_binding_name,
-                )
-            if self.stt is None:
-                ASCIIColors.warning(f"Failed to create STT binding: {stt_binding_name}. Available: {self.stt_binding_manager.get_available_bindings()}")
+                else:
+                    self.stt = self.stt_binding_manager.create_binding(
+                        binding_name=stt_binding_name,
+                    )
+                if self.stt is None:
+                    ASCIIColors.warning(f"Failed to create STT binding: {stt_binding_name}. Available: {self.stt_binding_manager.get_available_bindings()}")
+            except Exception as e:
+                trace_exception(e)
+                ASCIIColors.warning(f"Exception occurred while creating STT binding: {str(e)}")
+                self.stt = None
+                
         if ttv_binding_name:
-            if ttv_binding_config:
-                self.ttv = self.ttv_binding_manager.create_binding(
-                    binding_name=ttv_binding_name,
-                    **{
-                        k: v
-                        for k, v in ttv_binding_config.items()
-                        if k != "binding_name"
-                    }
-                )
+            try:
+                if ttv_binding_config:
+                    self.ttv = self.ttv_binding_manager.create_binding(
+                        binding_name=ttv_binding_name,
+                        **{
+                            k: v
+                            for k, v in ttv_binding_config.items()
+                            if k != "binding_name"
+                        }
+                    )
 
-            else:
-                self.ttv = self.ttv_binding_manager.create_binding(
-                    binding_name=ttv_binding_name
-                )
-            if self.ttv is None:
-                ASCIIColors.warning(f"Failed to create TTV binding: {ttv_binding_name}. Available: {self.ttv_binding_manager.get_available_bindings()}")
+                else:
+                    self.ttv = self.ttv_binding_manager.create_binding(
+                        binding_name=ttv_binding_name
+                    )
+                if self.ttv is None:
+                    ASCIIColors.warning(f"Failed to create TTV binding: {ttv_binding_name}. Available: {self.ttv_binding_manager.get_available_bindings()}")
+            except Exception as e:
+                trace_exception(e)
+                ASCIIColors.warning(f"Exception occurred while creating TTV binding: {str(e)}")
+                self.ttv = None
 
         if ttm_binding_name:
-            if ttm_binding_config:
-                self.ttm = self.ttm_binding_manager.create_binding(
-                    binding_name=ttm_binding_name,
-                    **{
-                        k: v
-                        for k, v in (ttm_binding_config or {}).items()
-                        if k != "binding_name"
-                    }
-                )
-            else:
-                self.ttm = self.ttm_binding_manager.create_binding(
-                    binding_name=ttm_binding_name
-                )
-            if self.ttm is None:
-                ASCIIColors.warning(f"Failed to create TTM binding: {ttm_binding_name}. Available: {self.ttm_binding_manager.get_available_bindings()}")
+            try:
+                if ttm_binding_config:
+                    self.ttm = self.ttm_binding_manager.create_binding(
+                        binding_name=ttm_binding_name,
+                        **{
+                            k: v
+                            for k, v in (ttm_binding_config or {}).items()
+                            if k != "binding_name"
+                        }
+                    )
+                else:
+                    self.ttm = self.ttm_binding_manager.create_binding(
+                        binding_name=ttm_binding_name
+                    )
+                if self.ttm is None:
+                    ASCIIColors.warning(f"Failed to create TTM binding: {ttm_binding_name}. Available: {self.ttm_binding_manager.get_available_bindings()}")
+            except Exception as e:
+                trace_exception(e)
+                ASCIIColors.warning(f"Exception occurred while creating TTM binding: {str(e)}")
+                self.ttm = None
 
         if mcp_binding_name:
-            if mcp_binding_config:
-                self.mcp = self.mcp_binding_manager.create_binding(
-                    binding_name=mcp_binding_name,
-                    **{
-                        k: v
-                        for k, v in (mcp_binding_config or {}).items()
-                        if k != "binding_name"
-                    }
-                )
-            else:
-                self.mcp = self.mcp_binding_manager.create_binding(
-                    mcp_binding_name
-                )
-            if self.mcp is None:
-                ASCIIColors.warning(f"Failed to create MCP binding: {mcp_binding_name}. Available: {self.mcp_binding_manager.get_available_bindings()}")
-
+            try:
+                if mcp_binding_config:
+                    self.mcp = self.mcp_binding_manager.create_binding(
+                        binding_name=mcp_binding_name,
+                        **{
+                            k: v
+                            for k, v in (mcp_binding_config or {}).items()
+                            if k != "binding_name"
+                        }
+                    )
+                else:
+                    self.mcp = self.mcp_binding_manager.create_binding(
+                        mcp_binding_name
+                    )
+                if self.mcp is None:
+                    ASCIIColors.warning(f"Failed to create MCP binding: {mcp_binding_name}. Available: {self.mcp_binding_manager.get_available_bindings()}")
+            except Exception as e:
+                trace_exception(e)
+                ASCIIColors.warning(f"Exception occurred while creating MCP binding: {str(e)}")
+                self.mcp = None            
         # --- Store Default Generation Parameters ---
 
         # --- Prompt Formatting Attributes ---
@@ -1465,7 +1476,7 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
                 return "🎨 Creating an image based on your request"
             
             # Handle RAG (data store) tools by their pattern
-            elif "research::" in tool_name:
+            elif "rag::" in tool_name:
                 # Extract the friendly name of the data source
                 source_name = tool_name.split("::")[-1].replace("_", " ").title()
                 return f"🔍 Searching {source_name} for relevant information"
@@ -1516,7 +1527,8 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
             final_answer_temperature=0.7
         if rag_top_k is None:
             rag_top_k=5
-
+            
+        tools_infos = []
         def log_event(desc, event_type=MSG_TYPE.MSG_TYPE_CHUNK, meta=None, event_id=None) -> Optional[str]:
             if not streaming_callback: return None
             is_start = event_type == MSG_TYPE.MSG_TYPE_STEP_START
@@ -1543,38 +1555,44 @@ Provide your response as a single JSON object inside a JSON markdown tag. Use th
             mcp_tools = self.mcp.discover_tools(force_refresh=True)
             if isinstance(use_mcps, list): 
                 filtered_tools = [t for t in mcp_tools if t["name"] in use_mcps]
+                tools_infos+=[f"    🛠️{f['name']}" for f in filtered_tools]
                 all_discovered_tools.extend(filtered_tools)
                 log_event(f"  ✅ Loaded {len(filtered_tools)} specific MCP tools: {', '.join(use_mcps)}", MSG_TYPE.MSG_TYPE_INFO)
             elif use_mcps is True: 
+                tools_infos+=[f"    🛠️{f['name']}" for f in mcp_tools]
                 all_discovered_tools.extend(mcp_tools)
                 log_event(f"  ✅ Loaded {len(mcp_tools)} MCP tools", MSG_TYPE.MSG_TYPE_INFO)
         
         if use_data_store:
             log_event(f"  📚 Setting up {len(use_data_store)} knowledge bases...", MSG_TYPE.MSG_TYPE_INFO)
             for name, info in use_data_store.items():
-                tool_name, description, call_fn = f"research::{name}", f"Queries the '{name}' knowledge base.", None
+                ASCIIColors.info(f"use_data_store item:\n{name}\n{info}")
+                tool_name, description, call_fn = f"rag::{name}", f"Queries the '{name}' knowledge base.", None
                 if callable(info): call_fn = info
                 elif isinstance(info, dict):
                     if "callable" in info and callable(info["callable"]): call_fn = info["callable"]
-                    description = info.get("description", description)
+                    description = info.get("description", "This is a datastore with the following description: \n" + description)
                 if call_fn:
                     visible_tools.append({"name": tool_name, "description": description, "input_schema": {"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]}})
                     rag_registry[tool_name] = call_fn
                     rag_tool_specs[tool_name] = {"default_top_k": rag_top_k, "default_min_sim": rag_min_similarity_percent}
-                    log_event(f"    📖 Ready: {name}", MSG_TYPE.MSG_TYPE_INFO)
-        
+                    tools_infos.append(f"    📖 {name}")
         visible_tools.extend(all_discovered_tools)
         built_in_tools = [
             {"name": "local_tools::final_answer", "description": "Provide the final answer directly to the user.", "input_schema": {}},
             {"name": "local_tools::request_clarification", "description": "Ask the user for more specific information when the request is ambiguous.", "input_schema": {"type": "object", "properties": {"question": {"type": "string"}}, "required": ["question"]}},
             {"name": "local_tools::revise_plan", "description": "Update the execution plan based on new discoveries or changing requirements.", "input_schema": {"type": "object", "properties": {"reason": {"type": "string"}, "new_plan": {"type": "array"}}, "required": ["reason", "new_plan"]}}
         ]
+        tools_infos+=[f"    🔨 final_answer","    🔨 request_clarification","    🔨 revise_plan"]
+        
+        
         if getattr(self, "tti", None): 
             built_in_tools.append({"name": "local_tools::generate_image", "description": "Generate an image from a text description.", "input_schema": {"type": "object", "properties": {"prompt": {"type": "string"}}, "required": ["prompt"]}})
         
         all_visible_tools = visible_tools + built_in_tools
         tool_summary = "\n".join([f"- **{t['name']}**: {t['description']}" for t in all_visible_tools[:20]])
         
+        log_event("\n".join(tools_infos), MSG_TYPE.MSG_TYPE_INFO)
         log_event(f"✅ Ready with {len(all_visible_tools)} total capabilities", MSG_TYPE.MSG_TYPE_STEP_END, event_id=discovery_step_id, meta={"tool_count": len(all_visible_tools), "mcp_tools": len(all_discovered_tools), "rag_tools": len(rag_registry)})
 
         # Enhanced triage with better prompting
@@ -1594,7 +1612,7 @@ AVAILABLE CAPABILITIES:
 Based on the request complexity and available tools, choose the optimal strategy:
 
 1. **DIRECT_ANSWER**: For simple greetings, basic questions, or requests that don't require any tools
-   - Use when: The request can be fully answered with your existing knowledge
+   - Use when: The request can be fully answered with your existing knowledge with confidence, and no tool seems to add any significant value to the answer
    - Example: "Hello", "What is Python?", "Explain quantum physics"
 
 2. **REQUEST_CLARIFICATION**: When the request is too vague or ambiguous
@@ -1612,16 +1630,14 @@ Based on the request complexity and available tools, choose the optimal strategy
 Provide your analysis in JSON format:
 {{"thought": "Detailed reasoning about the request complexity and requirements", "strategy": "ONE_OF_THE_FOUR_OPTIONS", "confidence": 0.8, "text_output": "Direct answer or clarification question if applicable", "required_tool_name": "specific tool name if SINGLE_TOOL strategy", "estimated_steps": 3}}"""
             
-            log_prompt("Triage Prompt", triage_prompt)
-            
             triage_schema = {
                 "thought": "string", "strategy": "string", "confidence": "number",
                 "text_output": "string", "required_tool_name": "string", "estimated_steps": "number"
             }
-            strategy_data = self.generate_structured_content(prompt=triage_prompt, schema=triage_schema, temperature=0.1, **llm_generation_kwargs)
+            strategy_data = self.generate_structured_content(prompt=triage_prompt, schema=triage_schema, temperature=0.1, system_prompt=system_prompt, **llm_generation_kwargs)
             strategy = strategy_data.get("strategy") if strategy_data else "COMPLEX_PLAN"
             
-            log_event(f"Strategy analysis complete", MSG_TYPE.MSG_TYPE_INFO, meta={
+            log_event(f"Strategy analysis complete.\n**confidence**: {strategy_data.get('confidence', 0.5)}\n**reasoning**: {strategy_data.get('thought', 'None')}", MSG_TYPE.MSG_TYPE_INFO, meta={
                 "strategy": strategy,
                 "confidence": strategy_data.get("confidence", 0.5),
                 "estimated_steps": strategy_data.get("estimated_steps", 1),
@@ -1760,7 +1776,7 @@ RESPONSE:"""
             }
             if tool_name in descriptions:
                 return descriptions[tool_name]
-            if "research::" in tool_name: 
+            if "rag::" in tool_name: 
                 return f"🔍 Searching {tool_name.split('::')[-1]} knowledge base"
             if requires_code: 
                 return "💻 Processing code"
@@ -1829,7 +1845,7 @@ RESPONSE:"""
         
         # Enhanced planning phase
         planning_step_id = log_event_fn("📋 Creating adaptive execution plan...", MSG_TYPE.MSG_TYPE_STEP_START)
-        execution_plan = planner.decompose_task(original_user_prompt, context or "")
+        execution_plan = planner.decompose_task(original_user_prompt, context or "", "\n".join([f"{tool['name']}:{tool['description']}" for tool in all_visible_tools]))
         current_plan_version = 1
         
         log_event_fn(f"Initial plan created with {len(execution_plan.tasks)} tasks", MSG_TYPE.MSG_TYPE_INFO, meta={
@@ -4309,27 +4325,29 @@ Provide the final aggregated answer in {output_format} format, directly addressi
         context_fill_percentage: float = 0.75,
         overlap_tokens: int = 150,
         expected_generation_tokens: int = 1500,
-        max_scratchpad_tokens: int = 4000,  # NEW: Hard limit for scratchpad
-        scratchpad_compression_threshold: int = 3000,  # NEW: When to compress
+        max_scratchpad_tokens: int = 4000,
+        scratchpad_compression_threshold: int = 3000,
         streaming_callback: Optional[Callable] = None,
         return_scratchpad_only: bool = False,
         debug: bool = True,
+        ctx_size=None,
         **kwargs
     ) -> str:
         """
         Processes long text with FIXED chunk sizing and managed scratchpad growth.
+        Now uses dynamic token calculation based on actual model tokenizer.
         """
 
         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}")
+        if not (0.1 <= context_fill_percentage <= 1.0):
+            raise ValueError(f"context_fill_percentage must be between 0.1 and 1.0, got {context_fill_percentage}")
 
         # Get context size
         try:
-            context_size = self.llm.get_context_size() or 8192
+            context_size = ctx_size or self.llm.default_ctx_size or self.llm.get_context_size() or 8192
         except:
             context_size = 8192
 
@@ -4346,26 +4364,97 @@ Provide the final aggregated answer in {output_format} format, directly addressi
             print(f"🔧 DEBUG: Tokenized into {len(tokens):,} word tokens")
 
         # ========================================
-        # FIXED: Calculate chunk size ONCE upfront
+        # ENHANCED: Dynamically calculate token sizes using actual tokenizer
         # ========================================
-        base_system_tokens = 150
-        user_template_tokens = 250
-        
+
+        # Create template system prompt to measure its token size
+        template_system_prompt = (
+            f"You are a component in a multi-step text processing pipeline analyzing step 1 of 100.\n\n"
+            f"**Your Task:** Analyze the 'New Text Chunk' and extract key information relevant to the 'Global Objective'. "
+            f"Review the 'Existing Scratchpad' to avoid repetition. Add ONLY new insights.\n\n"
+            f"**CRITICAL:** Do NOT repeat information already in the scratchpad. "
+            f"If no new relevant information exists, respond with '[No new information found in this chunk.]'"
+        )
+        base_system_tokens = len(self.tokenize(template_system_prompt))
+
+        # Create MINIMAL template user prompt (structure only, without content placeholders)
+        summarization_objective = contextual_prompt or "Create a comprehensive summary by extracting all key facts, concepts, and conclusions."
+
+        # Measure only the structural overhead (headers, formatting, instructions)
+        template_structure = (
+            f"--- Global Objective ---\n{summarization_objective}\n\n"
+            f"--- Progress ---\nStep 100/100 | 10 sections completed, 4000 tokens\n\n"  # Worst-case progress text
+            f"--- Existing Scratchpad (for context) ---\n"
+            f"--- New Text Chunk ---\n"
+            f"--- Instructions ---\n"
+            f"Extract NEW key information from this chunk that aligns with the objective. "
+            f"Be concise. Avoid repeating scratchpad content."
+        )
+        user_template_overhead = len(self.tokenize(template_structure))
+
+        if debug:
+            print(f"🔧 DEBUG: Computed system prompt tokens: {base_system_tokens}")
+            print(f"🔧 DEBUG: Computed user template overhead: {user_template_overhead}")
+            print(f"🔧 DEBUG: (Note: Scratchpad and chunk content allocated separately)")
+
         # Reserve space for maximum expected scratchpad size
         reserved_scratchpad_tokens = max_scratchpad_tokens
-        
+
         total_budget = int(context_size * context_fill_percentage)
-        used_tokens = base_system_tokens + user_template_tokens + reserved_scratchpad_tokens + expected_generation_tokens
-        
+        # Only count overhead, not the actual chunk/scratchpad content (that's reserved separately)
+        used_tokens = base_system_tokens + user_template_overhead + reserved_scratchpad_tokens + expected_generation_tokens
+
         # FIXED chunk size - never changes during processing
-        FIXED_CHUNK_SIZE = max(500, int(total_budget - used_tokens))
+        FIXED_CHUNK_SIZE = max(1024, int(total_budget - used_tokens))
+
         
         if debug:
-            print(f"🔧 DEBUG: FIXED chunk size: {FIXED_CHUNK_SIZE} tokens (will not change)")
-            print(f"🔧 DEBUG: Reserved scratchpad space: {reserved_scratchpad_tokens} tokens")
-            print(f"🔧 DEBUG: Total budget: {total_budget} tokens")
+            print(f"\n🔧 DEBUG: Token budget breakdown:")
+            print(f"  - Context size: {context_size} tokens")
+            print(f"  - Fill percentage: {context_fill_percentage} ({int(context_fill_percentage*100)}%)")
+            print(f"  - Total budget: {total_budget} tokens")
+            print(f"  - System prompt: {base_system_tokens} tokens")
+            print(f"  - User template overhead: {user_template_overhead} tokens")
+            print(f"  - Reserved scratchpad: {reserved_scratchpad_tokens} tokens")
+            print(f"  - Expected generation: {expected_generation_tokens} tokens")
+            print(f"  - Total overhead: {used_tokens} tokens")
+            print(f"  - Remaining for chunks: {total_budget - used_tokens} tokens")
+            print(f"🔧 DEBUG: FIXED chunk size: {FIXED_CHUNK_SIZE} tokens")
+            
+            # Safety check
+            if FIXED_CHUNK_SIZE == 1024:
+                print(f"⚠️  WARNING: Chunk size is at minimum (1024)!")
+                print(f"⚠️  Budget exhausted: {used_tokens} used / {total_budget} available")
+                print(f"⚠️  Consider reducing max_scratchpad_tokens or expected_generation_tokens")
 
         if streaming_callback:
+            streaming_callback(
+                "\n".join([
+                        f"\n🔧 DEBUG: Token budget breakdown:",
+                        f"  - Context size: {context_size} tokens",
+                        f"  - Fill percentage: {context_fill_percentage} ({int(context_fill_percentage*100)}%)",
+                        f"  - Total budget: {total_budget} tokens",
+                        f"  - System prompt: {base_system_tokens} tokens",
+                        f"  - User template overhead: {user_template_overhead} tokens",
+                        f"  - Reserved scratchpad: {reserved_scratchpad_tokens} tokens",
+                        f"  - Expected generation: {expected_generation_tokens} tokens",
+                        f"  - Total overhead: {used_tokens} tokens",
+                        f"  - Remaining for chunks: {total_budget - used_tokens} tokens",
+                        f"🔧 DEBUG: FIXED chunk size: {FIXED_CHUNK_SIZE} tokens"
+                        ]
+                ),
+                MSG_TYPE.MSG_TYPE_STEP
+            )            
+            if FIXED_CHUNK_SIZE == 1024:
+                streaming_callback(
+                    "\n".join([
+                            f"⚠️  WARNING: Chunk size is at minimum (1024)!",
+                            f"⚠️  Budget exhausted: {used_tokens} used / {total_budget} available",
+                            f"⚠️  Consider reducing max_scratchpad_tokens or expected_generation_tokens"
+                            ]
+                    ),
+                    MSG_TYPE.MSG_TYPE_STEP
+                )
             streaming_callback(
                 f"Context Budget: {FIXED_CHUNK_SIZE:,}/{total_budget:,} tokens per chunk (fixed)",
                 MSG_TYPE.MSG_TYPE_STEP,
@@ -4416,7 +4505,7 @@ Provide the final aggregated answer in {output_format} format, directly addressi
             print(f"🔧 DEBUG: Total estimated steps: {total_steps}")
 
         # ========================================
-        # NEW: Scratchpad compression helper
+        # NEW: Scratchpad compression helper with dynamic token counting
         # ========================================
         def compress_scratchpad(scratchpad_sections: list) -> list:
             """Compress scratchpad when it gets too large"""
@@ -4424,7 +4513,8 @@ Provide the final aggregated answer in {output_format} format, directly addressi
                 return scratchpad_sections
                 
             combined = "\n\n---\n\n".join(scratchpad_sections)
-            current_size = len(combined.split())
+            # ENHANCED: Use actual tokenizer to count
+            current_size = len(self.tokenize(combined))
             
             if current_size <= scratchpad_compression_threshold:
                 return scratchpad_sections
@@ -4448,7 +4538,8 @@ Provide the final aggregated answer in {output_format} format, directly addressi
                 )
                 
                 if debug:
-                    compressed_size = len(compressed.split())
+                    # ENHANCED: Use actual tokenizer
+                    compressed_size = len(self.tokenize(compressed))
                     print(f"🔧 DEBUG: Compressed to {compressed_size} tokens (reduction: {100*(1-compressed_size/current_size):.1f}%)")
                 
                 return [compressed]
@@ -4479,16 +4570,16 @@ Provide the final aggregated answer in {output_format} format, directly addressi
                     {"step": step_number, "total_steps": total_steps, "progress": progress}
                 )
 
-            # Check and compress scratchpad if needed
+            # ENHANCED: Check and compress scratchpad with actual token counting
             current_scratchpad = "\n\n---\n\n".join(chunk_summaries)
-            scratchpad_size = len(current_scratchpad.split())
+            scratchpad_size = len(self.tokenize(current_scratchpad)) if current_scratchpad else 0
             
             if scratchpad_size > scratchpad_compression_threshold:
                 if debug:
                     print(f"🔧 DEBUG: Scratchpad size ({scratchpad_size}) exceeds threshold, compressing...")
                 chunk_summaries = compress_scratchpad(chunk_summaries)
                 current_scratchpad = "\n\n---\n\n".join(chunk_summaries)
-                scratchpad_size = len(current_scratchpad.split())
+                scratchpad_size = len(self.tokenize(current_scratchpad)) if current_scratchpad else 0
 
             try:
                 system_prompt = (
@@ -4512,8 +4603,15 @@ Provide the final aggregated answer in {output_format} format, directly addressi
                     f"Be concise. Avoid repeating scratchpad content."
                 )
 
+                # ENHANCED: Compute actual prompt size
+                actual_prompt_tokens = len(self.tokenize(user_prompt))
+                actual_system_tokens = len(self.tokenize(system_prompt))
+
                 if debug:
-                    print(f"🔧 DEBUG: Prompt size: {len(user_prompt)} chars, Scratchpad: {scratchpad_size} tokens")
+                    print(f"🔧 DEBUG: Actual prompt tokens: {actual_prompt_tokens}")
+                    print(f"🔧 DEBUG: Actual system tokens: {actual_system_tokens}")
+                    print(f"🔧 DEBUG: Total input tokens: {actual_prompt_tokens + actual_system_tokens}")
+                    print(f"🔧 DEBUG: Scratchpad: {scratchpad_size} tokens")
 
                 chunk_summary = self.remove_thinking_blocks(self.llm.generate_text(user_prompt, system_prompt=system_prompt, **kwargs))
 
@@ -4589,7 +4687,7 @@ Provide the final aggregated answer in {output_format} format, directly addressi
                 streaming_callback("Returning scratchpad content", MSG_TYPE.MSG_TYPE_STEP, {})
             return final_scratchpad.strip()
 
-        # Final synthesis
+        # Final synthesis with STRONG objective reinforcement
         if streaming_callback:
             streaming_callback("Synthesizing final response...", MSG_TYPE.MSG_TYPE_STEP_START, {"progress": 95})
 
@@ -4603,20 +4701,47 @@ Provide the final aggregated answer in {output_format} format, directly addressi
         synthesis_objective = contextual_prompt or "Provide a comprehensive, well-structured summary and analysis."
 
         if debug:
-            print(f"🔧 DEBUG: Synthesizing from {len(combined_scratchpad):,} chars, {len(chunk_summaries)} sections")
+            final_scratchpad_tokens = len(self.tokenize(combined_scratchpad))
+            print(f"🔧 DEBUG: Synthesizing from {len(combined_scratchpad):,} chars, {final_scratchpad_tokens} tokens, {len(chunk_summaries)} sections")
 
+        # ENHANCED: Strong objective-focused synthesis
         synthesis_system_prompt = (
-            "You are an expert at synthesizing information. "
-            "Consolidate the analysis sections into a coherent final response. "
-            "Eliminate redundancy, organize logically, and use markdown formatting."
+            f"You are completing a multi-step text processing task. "
+            f"Your role is to take analysis sections and produce the FINAL OUTPUT that directly fulfills the user's original objective.\n\n"
+            f"**CRITICAL:** Your output must DIRECTLY ADDRESS the user's objective, NOT just summarize the sections. "
+            f"The sections are intermediate work - transform them into the final deliverable the user requested."
         )
 
+        # ENHANCED: Explicit task reinforcement with examples of what NOT to do
+        task_type_hint = ""
+        if contextual_prompt:
+            lower_prompt = contextual_prompt.lower()
+            if any(word in lower_prompt for word in ['extract', 'list', 'identify', 'find']):
+                task_type_hint = "\n**Task Type:** This is an EXTRACTION/IDENTIFICATION task. Provide a structured list or catalog of items found, NOT a narrative summary."
+            elif any(word in lower_prompt for word in ['analyze', 'evaluate', 'assess', 'examine']):
+                task_type_hint = "\n**Task Type:** This is an ANALYSIS task. Provide insights, patterns, and evaluations, NOT just a description of content."
+            elif any(word in lower_prompt for word in ['compare', 'contrast', 'difference']):
+                task_type_hint = "\n**Task Type:** This is a COMPARISON task. Highlight similarities and differences, NOT separate summaries."
+            elif any(word in lower_prompt for word in ['answer', 'question', 'explain why', 'how does']):
+                task_type_hint = "\n**Task Type:** This is a QUESTION-ANSWERING task. Provide a direct answer, NOT a general overview."
+
         synthesis_user_prompt = (
-            f"--- Final Objective ---\n{synthesis_objective}\n\n"
-            f"--- Collected Analysis Sections ---\n{combined_scratchpad}\n\n"
-            f"--- Instructions ---\n"
-            f"Synthesize all information into a comprehensive response addressing the objective. "
-            f"Organize with markdown headers, remove repetition, create a polished final document."
+            f"=== ORIGINAL USER OBJECTIVE (MOST IMPORTANT) ===\n{synthesis_objective}\n"
+            f"{task_type_hint}\n\n"
+            f"=== ANALYSIS SECTIONS (Raw Working Material) ===\n{combined_scratchpad}\n\n"
+            f"=== YOUR TASK ===\n"
+            f"Transform the analysis sections above into a final output that DIRECTLY FULFILLS the original objective.\n\n"
+            f"**DO:**\n"
+            f"- Focus exclusively on satisfying the user's original objective stated above\n"
+            f"- Organize information in whatever format best serves that objective\n"
+            f"- Remove redundancy and consolidate related points\n"
+            f"- Use markdown formatting for clarity\n\n"
+            f"**DO NOT:**\n"
+            f"- Provide a generic summary of the sections\n"
+            f"- Describe what the sections contain\n"
+            f"- Create an overview of the analysis process\n"
+            f"- Change the task into something different\n\n"
+            f"Remember: The user asked for '{synthesis_objective}' - deliver exactly that."
         )
 
         try:

lollms_client/lollms_discussion.py

@@ -1208,14 +1208,27 @@ class LollmsDiscussion:
             prompt_for_agent = self.export("markdown", branch_tip_id if branch_tip_id else self.active_branch_id)
             if debug:
                 ASCIIColors.cyan("\n" + "="*50 + "\n--- DEBUG: AGENTIC TURN TRIGGERED ---\n" + f"--- PROMPT FOR AGENT (from discussion history) ---\n{prompt_for_agent}\n" + "="*50 + "\n")
-
+            
+            
+            # Combine system prompt and data zones
+            system_prompt_part = (self._system_prompt or "").strip()
+            data_zone_part = self.get_full_data_zone() # This now returns a clean, multi-part block or an empty string
+            full_system_prompt = ""
+
+            # Combine them intelligently
+            if system_prompt_part and data_zone_part:
+                full_system_prompt = f"{system_prompt_part}\n\n{data_zone_part}"
+            elif system_prompt_part:
+                full_system_prompt = system_prompt_part
+            else:
+                full_system_prompt = data_zone_part
             agent_result = self.lollmsClient.generate_with_mcp_rag(
                 prompt=prompt_for_agent,
                 use_mcps=effective_use_mcps,
                 use_data_store=use_data_store,
                 max_reasoning_steps=max_reasoning_steps,
                 images=images,
-                system_prompt = self._system_prompt,
+                system_prompt = full_system_prompt,
                 debug=debug,
                 **kwargs
             )

lollms_client/lollms_stt_binding.py

@@ -4,7 +4,7 @@ import importlib
 from pathlib import Path
 from typing import Optional, List, Dict, Any, Union
 from ascii_colors import trace_exception
-
+import yaml
 class LollmsSTTBinding(ABC):
     """Abstract base class for all LOLLMS Speech-to-Text bindings."""
 
@@ -122,4 +122,58 @@ class LollmsSTTBindingManager:
             list[str]: List of binding names.
         """
         return [binding_dir.name for binding_dir in self.stt_bindings_dir.iterdir()
-                if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]
+                if binding_dir.is_dir() and (binding_dir / "__init__.py").exists()]
+
+
+    @staticmethod
+    def _get_fallback_description(binding_name: str) -> Dict:
+        return {
+            "binding_name": binding_name,
+            "title": binding_name.replace("_", " ").title(),
+            "author": "Unknown",
+            "version": "N/A",
+            "description": f"A binding for {binding_name}. No description.yaml file was found.",
+            "input_parameters": [
+                 {
+                    "name": "model_name",
+                    "type": "str",
+                    "description": "The model name or ID to be used.",
+                    "mandatory": False,
+                    "default": ""
+                }
+            ],
+            "generate_audio_parameters": []
+        }
+    @staticmethod
+    def get_bindings_list(stt_bindings_dir: Union[str, Path]) -> List[Dict]:
+        bindings_dir = Path(stt_bindings_dir)
+        if not bindings_dir.is_dir():
+            return []
+
+        bindings_list = []
+        for binding_folder in bindings_dir.iterdir():
+            if binding_folder.is_dir() and (binding_folder / "__init__.py").exists():
+                binding_name = binding_folder.name
+                description_file = binding_folder / "description.yaml"
+                
+                binding_info = {}
+                if description_file.exists():
+                    try:
+                        with open(description_file, 'r', encoding='utf-8') as f:
+                            binding_info = yaml.safe_load(f)
+                        binding_info['binding_name'] = binding_name
+                    except Exception as e:
+                        print(f"Error loading description.yaml for {binding_name}: {e}")
+                        binding_info = LollmsSTTBindingManager._get_fallback_description(binding_name)
+                else:
+                    binding_info = LollmsSTTBindingManager._get_fallback_description(binding_name)
+                
+                bindings_list.append(binding_info)
+
+        return sorted(bindings_list, key=lambda b: b.get('title', b['binding_name']))
+    
+
+def get_available_bindings(stt_bindings_dir: Union[str, Path] = None) -> List[Dict]:
+    if stt_bindings_dir is None:
+        stt_bindings_dir = Path(__file__).resolve().parent / "stt_bindings"
+    return LollmsSTTBindingManager.get_bindings_list(stt_bindings_dir)

lollms_client/stt_bindings/whisper/__init__.py

@@ -82,6 +82,7 @@ class WhisperSTTBinding(LollmsSTTBinding):
                                     If None, `torch` will attempt to auto-detect. Defaults to None.
         """
         super().__init__(binding_name="whisper") # Not applicable
+        self.default_model_name = kwargs.get("model_name", "base")
 
         if not _whisper_installed:
             raise ImportError(f"Whisper STT binding dependencies not met. Please ensure 'openai-whisper' and 'torch' are installed. Error: {_whisper_installation_error}")
@@ -104,7 +105,7 @@ class WhisperSTTBinding(LollmsSTTBinding):
 
     def _load_whisper_model(self, model_name_to_load: str):
         """Loads or reloads the Whisper model."""
-        if model_name_to_load not in self.WHISPER_MODEL_SIZES:
+        if model_name_to_load not in whisper.available_models():
             ASCIIColors.warning(f"'{model_name_to_load}' is not a standard Whisper model size. Attempting to load anyway. Known sizes: {self.WHISPER_MODEL_SIZES}")
 
         if self.model is not None and self.loaded_model_name == model_name_to_load:
@@ -202,7 +203,7 @@ class WhisperSTTBinding(LollmsSTTBinding):
         Returns:
             List[str]: A list of available Whisper model size identifiers.
         """
-        return self.WHISPER_MODEL_SIZES.copy() # Return a copy
+        return whisper.available_models() # Return a copy
 
     def __del__(self):
         """Clean up: Unload the model to free resources."""

lollms_client/stt_bindings/whispercpp/__init__.py

@@ -31,6 +31,8 @@ class WhisperCppSTTBinding(LollmsSTTBinding):
         n_threads = kwargs.get("n_threads", 4)
         extra_whisper_args = kwargs.get("extra_whisper_args", [])  # e.g. ["--no-timestamps"]
 
+        self.default_model_name = "base"
+
         # --- Validate FFMPEG ---
         self.ffmpeg_exe = None
         if ffmpeg_path:
@@ -376,4 +378,8 @@ if __name__ == '__main__':
                     TEST_MODELS_SEARCH_DIR.rmdir()
             except OSError: pass # Ignore if not empty or other issues
 
-    ASCIIColors.yellow("\n--- WhisperCppSTTBinding Test Finished ---")
+    ASCIIColors.yellow("\n--- WhisperCppSTTBinding Test Finished ---")
+
+    def list_models(self) -> List[Dict[str, Any]]:
+        return ["base" , "small", "medium", "large"]
+

lollms_client/tti_bindings/diffusers/__init__.py

@@ -45,7 +45,7 @@ class DiffusersBinding(LollmsTTIBinding):
 
         self.config = kwargs
         self.host = kwargs.get("host", "localhost")
-        self.port = kwargs.get("port", 9630)
+        self.port = kwargs.get("port", 9632)
         self.auto_start_server = kwargs.get("auto_start_server", True)
         self.server_process = None
         self.base_url = f"http://{self.host}:{self.port}"
@@ -61,7 +61,7 @@ class DiffusersBinding(LollmsTTIBinding):
     def is_server_running(self) -> bool:
         """Checks if the server is already running and responsive."""
         try:
-            response = requests.get(f"{self.base_url}/status", timeout=2)
+            response = requests.get(f"{self.base_url}/status", timeout=4)
             if response.status_code == 200 and response.json().get("status") == "running":
                 return True
         except requests.exceptions.RequestException:
@@ -90,7 +90,7 @@ class DiffusersBinding(LollmsTTIBinding):
         try:
             # Try to acquire the lock with a timeout. If another process is starting
             # the server, this will wait until it's finished.
-            with lock.acquire(timeout=60):
+            with lock.acquire(timeout=3):
                 # After acquiring the lock, we MUST re-check if the server is running.
                 # Another process might have started it and released the lock while we were waiting.
                 if not self.is_server_running():
@@ -105,7 +105,7 @@ class DiffusersBinding(LollmsTTIBinding):
             # This happens if the process holding the lock takes more than 60 seconds to start the server.
             # We don't try to start another one. We just wait for the existing one to be ready.
             ASCIIColors.yellow("Could not acquire lock, another process is taking a long time to start the server. Waiting...")
-            self._wait_for_server(timeout=300) # Give it a longer timeout here just in case.
+            self._wait_for_server(timeout=60) # Give it a longer timeout here just in case.
 
         # A final verification to ensure we are connected.
         if not self.is_server_running():
@@ -214,7 +214,7 @@ class DiffusersBinding(LollmsTTIBinding):
         self.server_process = subprocess.Popen(command, creationflags=creationflags)
         ASCIIColors.info("Diffusers server process launched in the background.")
 
-    def _wait_for_server(self, timeout=300):
+    def _wait_for_server(self, timeout=30):
         """Waits for the server to become responsive."""
         ASCIIColors.info("Waiting for Diffusers server to become available...")
         start_time = time.time()
@@ -374,4 +374,4 @@ class DiffusersBinding(LollmsTTIBinding):
     def __del__(self):
         # The client destructor does not stop the server,
         # as it is a shared resource for all worker processes.
-        pass
+        pass

lollms_client/tti_bindings/diffusers/server/main.py

@@ -60,66 +60,14 @@ MODELS_PATH = Path("./models")
 
 # --- START: Core Logic (Complete and Unabridged) ---
 CIVITAI_MODELS = {
-    "realistic-vision-v6": {
-        "display_name": "Realistic Vision V6.0", "url": "https://civitai.com/api/download/models/501240?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "realisticVisionV60_v60B1.safetensors", "description": "Photorealistic SD1.5 checkpoint.", "owned_by": "civitai"
-    },
-    "absolute-reality": {
-        "display_name": "Absolute Reality", "url": "https://civitai.com/api/download/models/132760?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "absolutereality_v181.safetensors", "description": "General realistic SD1.5.", "owned_by": "civitai"
-    },
-    "dreamshaper-8": {
+    "DreamShaper-8": {
         "display_name": "DreamShaper 8", "url": "https://civitai.com/api/download/models/128713",
         "filename": "dreamshaper_8.safetensors", "description": "Versatile SD1.5 style model.", "owned_by": "civitai"
     },
-    "juggernaut-xl": {
+    "Juggernaut-xl": {
         "display_name": "Juggernaut XL", "url": "https://civitai.com/api/download/models/133005",
         "filename": "juggernautXL_version6Rundiffusion.safetensors", "description": "Artistic SDXL.", "owned_by": "civitai"
     },
-    "lyriel-v1.6": {
-        "display_name": "Lyriel v1.6", "url": "https://civitai.com/api/download/models/72396?type=Model&format=SafeTensor&size=full&fp=fp16",
-        "filename": "lyriel_v16.safetensors", "description": "Fantasy/stylized SD1.5.", "owned_by": "civitai"
-    },
-    "ui_icons": {
-        "display_name": "UI Icons", "url": "https://civitai.com/api/download/models/367044?type=Model&format=SafeTensor&size=full&fp=fp16",
-        "filename": "uiIcons_v10.safetensors", "description": "A model for generating UI icons.", "owned_by": "civitai"
-    },
-    "meinamix": {
-        "display_name": "MeinaMix", "url": "https://civitai.com/api/download/models/948574?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "meinamix_meinaV11.safetensors", "description": "Anime/illustration SD1.5.", "owned_by": "civitai"
-    },
-    "rpg-v5": {
-        "display_name": "RPG v5", "url": "https://civitai.com/api/download/models/124626?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "rpg_v5.safetensors", "description": "RPG assets SD1.5.", "owned_by": "civitai"
-    },
-    "pixel-art-xl": {
-        "display_name": "Pixel Art XL", "url": "https://civitai.com/api/download/models/135931?type=Model&format=SafeTensor",
-        "filename": "pixelartxl_v11.safetensors", "description": "Pixel art SDXL.", "owned_by": "civitai"
-    },
-    "lowpoly-world": {
-        "display_name": "Lowpoly World", "url": "https://civitai.com/api/download/models/146502?type=Model&format=SafeTensor",
-        "filename": "LowpolySDXL.safetensors", "description": "Lowpoly style SD1.5.", "owned_by": "civitai"
-    },
-    "toonyou": {
-        "display_name": "ToonYou", "url": "https://civitai.com/api/download/models/125771?type=Model&format=SafeTensor&size=pruned&fp=fp16",
-        "filename": "toonyou_beta6.safetensors", "description": "Cartoon/Disney SD1.5.", "owned_by": "civitai"
-    },
-    "papercut": {
-        "display_name": "Papercut", "url": "https://civitai.com/api/download/models/133503?type=Model&format=SafeTensor",
-        "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"
-    },
 }
 
 HF_PUBLIC_MODELS = {
@@ -183,6 +131,7 @@ SCHEDULER_MAPPING = {
     "dpm2_karras": "KDPM2DiscreteScheduler", "dpm2_a": "KDPM2AncestralDiscreteScheduler", "dpm2_a_karras": "KDPM2AncestralDiscreteScheduler",
     "euler": "EulerDiscreteScheduler", "euler_a": "EulerAncestralDiscreteScheduler", "heun": "HeunDiscreteScheduler", "lms": "LMSDiscreteScheduler"
 }
+
 SCHEDULER_USES_KARRAS_SIGMAS = [
     "dpm_multistep_karras","dpm++_2m_karras","dpm++_2s_ancestral_karras", "dpm++_sde_karras","heun_karras","lms_karras",
     "dpm++_2m_sde_karras","dpm2_karras","dpm2_a_karras"
@@ -604,7 +553,7 @@ class ServerState:
         return {
             "model_name": "", "device": "auto", "torch_dtype_str": "auto", "use_safetensors": True,
             "scheduler_name": "default", "safety_checker_on": True, "num_inference_steps": 25,
-            "guidance_scale": 7.0, "width": 512, "height": 512, "seed": -1,
+            "guidance_scale": 7.0, "width": 1024, "height": 1024, "seed": -1,
             "enable_cpu_offload": False, "enable_sequential_cpu_offload": False, "enable_xformers": False,
             "hf_variant": None, "hf_token": None, "hf_cache_path": None, "local_files_only": False,
             "unload_inactive_model_after": 0
@@ -749,8 +698,8 @@ async def generate_image(request: T2IRequest):
         # Add prompts and ensure types for specific args
         pipeline_args["prompt"] = request.prompt
         pipeline_args["negative_prompt"] = request.negative_prompt
-        pipeline_args["width"] = int(pipeline_args.get("width", 512))
-        pipeline_args["height"] = int(pipeline_args.get("height", 512))
+        pipeline_args["width"] = int(pipeline_args.get("width", 1024))
+        pipeline_args["height"] = int(pipeline_args.get("height", 1024))
         pipeline_args["num_inference_steps"] = int(pipeline_args.get("num_inference_steps", 25))
         pipeline_args["guidance_scale"] = float(pipeline_args.get("guidance_scale", 7.0))
 
@@ -989,4 +938,4 @@ if __name__ == "__main__":
     else:
         ASCIIColors.info(f"Detected device: {state.config['device']}")
 
-    uvicorn.run(app, host=args.host, port=args.port, reload=False)
+    uvicorn.run(app, host=args.host, port=args.port, reload=False)

lollms_client/tts_bindings/xtts/__init__.py

@@ -32,7 +32,7 @@ class XTTSClientBinding(LollmsTTSBinding):
 
         self.config = kwargs
         self.host = kwargs.get("host", "localhost")
-        self.port = kwargs.get("port", 8081)
+        self.port = kwargs.get("port", 9633)
         self.auto_start_server = kwargs.get("auto_start_server", True)
         self.server_process = None
         self.base_url = f"http://{self.host}:{self.port}"
@@ -69,7 +69,7 @@ class XTTSClientBinding(LollmsTTSBinding):
             return
 
         try:
-            with lock.acquire(timeout=60):
+            with lock.acquire(timeout=10):
                 if not self.is_server_running():
                     ASCIIColors.yellow("Lock acquired. Starting dedicated XTTS server...")
                     self.start_server()
@@ -78,7 +78,7 @@ class XTTSClientBinding(LollmsTTSBinding):
                     ASCIIColors.green("Server was started by another process while we waited. Connected successfully.")
         except Timeout:
             ASCIIColors.yellow("Could not acquire lock, another process is starting the server. Waiting...")
-            self._wait_for_server(timeout=180)
+            self._wait_for_server(timeout=60)
 
         if not self.is_server_running():
             raise RuntimeError("Failed to start or connect to the XTTS server after all attempts.")
@@ -140,7 +140,7 @@ class XTTSClientBinding(LollmsTTSBinding):
         self.server_process = subprocess.Popen(command, creationflags=creationflags)
         ASCIIColors.info("XTTS server process launched in the background.")
 
-    def _wait_for_server(self, timeout=1):
+    def _wait_for_server(self, timeout=10):
         """Waits for the server to become responsive."""
         ASCIIColors.info("Waiting for XTTS server to become available...")
         start_time = time.time()

{lollms_client-1.6.7.dist-info → lollms_client-1.6.10.dist-info}/METADATA

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

{lollms_client-1.6.7.dist-info → lollms_client-1.6.10.dist-info}/RECORD

@@ -1,15 +1,15 @@
-lollms_client/__init__.py,sha256=CrN8dkGE49W-rpFHEln-GE74Rp-Ezq3zbu5sRAcnvXc,1146
-lollms_client/lollms_agentic.py,sha256=pQiMEuB_XkG29-SW6u4KTaMFPr6eKqacInggcCuCW3k,13914
+lollms_client/__init__.py,sha256=0D-nwmkSe8qYbyPSuKdYU09t7x5P2BYwfpI4mbzEZlU,1147
+lollms_client/lollms_agentic.py,sha256=ljalnmeSU-sbzH19-c9TzrJ-HhEeo4mxXmpJGkXj720,14094
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=kF42KKd9UCOr_-ME0vgB0_1Ae00B4ZWXjfTvFymeRP0,244203
-lollms_client/lollms_discussion.py,sha256=LZc9jYbUMRTovehiFJKEp-NXuCl_WnrqUtT3t4Nzayk,123922
+lollms_client/lollms_core.py,sha256=PGHPu_V5rKnO-032EjgMw8M5T0SLpNOWrzSUlWKBBgE,253052
+lollms_client/lollms_discussion.py,sha256=4uzXLqGz72xZcXEtamWGudTOR54cYwuo6k8JY37scqY,124574
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
 lollms_client/lollms_llm_binding.py,sha256=_6d0q9g9lk8FRZ1oYnLpuqG7Y_WLyBJBn4ANdk-C8gU,25020
 lollms_client/lollms_mcp_binding.py,sha256=psb27A23VFWDfZsR2WUbQXQxiZDW5yfOak6ZtbMfszI,10222
 lollms_client/lollms_mcp_security.py,sha256=FhVTDhSBjksGEZnopVnjFmEF5dv7D8bBTqoaj4BiF0E,3562
 lollms_client/lollms_personality.py,sha256=kGuFwmgA9QDLcQlLQ9sKeceMujdEo0Aw28fN5H8MpjI,8847
 lollms_client/lollms_python_analyzer.py,sha256=7gf1fdYgXCOkPUkBAPNmr6S-66hMH4_KonOMsADASxc,10246
-lollms_client/lollms_stt_binding.py,sha256=jAUhLouEhh2hmm1bK76ianfw_6B59EHfY3FmLv6DU-g,5111
+lollms_client/lollms_stt_binding.py,sha256=WkREwu0uc0UzeCv5Z9ok8AFG42iBq20ZOQJnydSTE0s,7505
 lollms_client/lollms_tti_binding.py,sha256=MhDntyXVNoZeqMH0YpoNtiLijXPL8Y--if2qjQAS0-w,8520
 lollms_client/lollms_ttm_binding.py,sha256=FjVVSNXOZXK1qvcKEfxdiX6l2b4XdGOSNnZ0utAsbDg,4167
 lollms_client/lollms_tts_binding.py,sha256=k13rNq4YmuR50kkAEacwADW7COoDUOMLGAcnm27xjO4,5150
@@ -49,11 +49,11 @@ lollms_client/mcp_bindings/remote_mcp/__init__.py,sha256=YpSclbNJDYVUe2W0H5Xki4g
 lollms_client/mcp_bindings/standard_mcp/__init__.py,sha256=wJQofr4zS5RIS9V5_WuMMFsJxSDJgXDW3PQPX1hlx6g,31519
 lollms_client/stt_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lollms_client/stt_bindings/lollms/__init__.py,sha256=9Vmn1sQQZKLGLe7nZnc-0LnNeSY8r9xw3pYZF-wVtPo,5889
-lollms_client/stt_bindings/whisper/__init__.py,sha256=1Ej67GdRKBy1bba14jMaYDYHiZkxJASkWm5eF07ztDQ,15363
-lollms_client/stt_bindings/whispercpp/__init__.py,sha256=xSAQRjAhljak3vWCpkP0Vmdb6WmwTzPjXyaIB85KLGU,21439
+lollms_client/stt_bindings/whisper/__init__.py,sha256=HVVYRGIPkTTwNw5uhvxvRkSYeAv6nNRZp_geS8SwKZ4,15428
+lollms_client/stt_bindings/whispercpp/__init__.py,sha256=5YQKFy3UaN-S-HGZiFCIcuPGTJTELPgqqct1AcTqz-Q,21595
 lollms_client/tti_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client/tti_bindings/diffusers/__init__.py,sha256=esrcyy_z_6HVCFKMVXl1h_qY_pX3kMHwO81M2C8hSIg,17706
-lollms_client/tti_bindings/diffusers/server/main.py,sha256=7xWANWnxHeDAF_NQTbJD4QToxoVtaAEdxGHMXOotz5s,51907
+lollms_client/tti_bindings/diffusers/__init__.py,sha256=_Nd3OotY1kBlEmHBuxVsNwIc_vvUy8sBo1Ug9_lUOzI,17705
+lollms_client/tti_bindings/diffusers/server/main.py,sha256=-Eo9vrpsK_LXRFJWkplriSdUX8VnkcL6tfFdxontNnM,48136
 lollms_client/tti_bindings/gemini/__init__.py,sha256=eYGz6gnOxWGdJu2O0H-EwGG-Hg7Yo3Hzsgn4neqx29Q,12963
 lollms_client/tti_bindings/leonardo_ai/__init__.py,sha256=pUbF1rKPZib1x0Kn2Bk1A7sTFWmZzNG02kmW6Iu1j2w,5885
 lollms_client/tti_bindings/lollms/__init__.py,sha256=5Tnsn4b17djvieQkcjtIDBm3qf0pg5ZWWov-4_2wmo0,8762
@@ -76,13 +76,13 @@ lollms_client/tts_bindings/piper_tts/__init__.py,sha256=7LQUuWV8I3IEdacc65NRHmDf
 lollms_client/tts_bindings/piper_tts/server/install_piper.py,sha256=g71Ne2T18wAytOPipfQ9DNeTAOD9PrII5qC-vr9DtLA,3256
 lollms_client/tts_bindings/piper_tts/server/main.py,sha256=DMozfSR1aCbrlmOXltRFjtXhYhXajsGcNKQjsWgRwZk,17402
 lollms_client/tts_bindings/piper_tts/server/setup_voices.py,sha256=UdHaPa5aNcw8dR-aRGkZr2OfSFFejH79lXgfwT0P3ss,1964
-lollms_client/tts_bindings/xtts/__init__.py,sha256=sQnmlXbFb5r6mX-4DfExuM7YJ_aSv551NM8ZzTrMauo,8073
+lollms_client/tts_bindings/xtts/__init__.py,sha256=q5xuNUYz4l9ajmZo4yvcTgxPuv9HT6T16u-weh3lzC8,8073
 lollms_client/tts_bindings/xtts/server/main.py,sha256=feTAX4eAo2HY6PpcDTrgRMak5AXocO7UIhKPuGuWpxY,12303
 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.6.7.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-1.6.7.dist-info/METADATA,sha256=c5Bud1Xae1bMbN5IZVYYJNva_f7DPvFaxrNnaHcRsSE,76835
-lollms_client-1.6.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-1.6.7.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
-lollms_client-1.6.7.dist-info/RECORD,,
+lollms_client-1.6.10.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-1.6.10.dist-info/METADATA,sha256=Mqk7RqLL6F5By0K_XIJemPSNoQhDcaW9JBT5-H9Tewg,76836
+lollms_client-1.6.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-1.6.10.dist-info/top_level.txt,sha256=Bk_kz-ri6Arwsk7YG-T5VsRorV66uVhcHGvb_g2WqgE,14
+lollms_client-1.6.10.dist-info/RECORD,,