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

lollms_client/llm_bindings/llamacpp/__init__.py

@@ -352,8 +352,11 @@ class LlamaCppServerBinding(LollmsLLMBinding):
 
 
     def load_model(self, model_name_or_path: str) -> bool:
-        resolved_model_path = self._resolve_model_path(model_name_or_path)
-        
+        try:
+            resolved_model_path = self._resolve_model_path(model_name_or_path)
+        except Exception as ex:
+            trace_exception(ex)
+            return False
         # Determine the clip_model_path for this server instance
         # Priority: 1. Explicit `clip_model_path` from init (if exists) 2. Auto-detection
         final_clip_model_path: Optional[Path] = None

lollms_client/lollms_core.py

@@ -147,9 +147,6 @@ class LollmsClient():
             available = self.binding_manager.get_available_bindings()
             raise ValueError(f"Failed to create LLM binding: {binding_name}. Available: {available}")
 
-        # Determine the effective host address (use LLM binding's if initial was None)
-        effective_host_address = self.host_address
-
         # --- Modality Binding Setup ---
         self.tts_binding_manager = LollmsTTSBindingManager(tts_bindings_dir)
         self.tti_binding_manager = LollmsTTIBindingManager(tti_bindings_dir)
@@ -2961,7 +2958,6 @@ Provide the final aggregated answer in {output_format} format, directly addressi
         callback("Deep analysis complete.", MSG_TYPE.MSG_TYPE_STEP_END)
         return final_output
 
-
     def summarize(
         self,
         text_to_summarize: str,
@@ -2990,6 +2986,7 @@ Provide the final aggregated answer in {output_format} format, directly addressi
                                           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).
 
@@ -3004,12 +3001,17 @@ Provide the final aggregated answer in {output_format} format, directly addressi
         
         if len(tokens) <= chunk_size_tokens:
             if streaming_callback:
-                streaming_callback("Text is short enough for a single summary.", MSG_TYPE.MSG_TYPE_STEP)
+                streaming_callback("Text is short enough for a single summary.", MSG_TYPE.MSG_TYPE_STEP, {"progress": 0})
             
             prompt_objective = contextual_prompt or "Provide a comprehensive summary of the following text."
             final_prompt = f"{prompt_objective}\n\n--- Text to Summarize ---\n{text_to_summarize}"
             
-            return self.generate_text(final_prompt, **kwargs)
+            summary = self.generate_text(final_prompt, **kwargs)
+            
+            if streaming_callback:
+                streaming_callback("Summary generated.", MSG_TYPE.MSG_TYPE_STEP, {"progress": 100})
+            
+            return summary
 
         # --- Stage 1: Chunking and Independent Summarization ---
         chunks = []
@@ -3021,13 +3023,21 @@ Provide the final aggregated answer in {output_format} format, directly addressi
 
         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."
         chunk_summary_prompt_template = f"{summarization_objective}\n\n--- Text Excerpt ---\n{{chunk_text}}"
 
         for i, chunk in enumerate(chunks):
+            progress_before = (i / total_steps) * 100
             if streaming_callback:
-                streaming_callback(f"Summarizing chunk {i + 1} of {len(chunks)}...", MSG_TYPE.MSG_TYPE_STEP_START, {"id": f"chunk_{i+1}"})
+                streaming_callback(
+                    f"Summarizing chunk {i + 1} of {len(chunks)}...", 
+                    MSG_TYPE.MSG_TYPE_STEP_START, 
+                    {"id": f"chunk_{i+1}", "progress": progress_before}
+                )
 
             prompt = chunk_summary_prompt_template.format(chunk_text=chunk)
             
@@ -3035,8 +3045,14 @@ Provide the final aggregated answer in {output_format} format, directly addressi
                 # Generate summary for the current chunk
                 chunk_summary = self.generate_text(prompt, **kwargs)
                 chunk_summaries.append(chunk_summary)
+                
+                progress_after = ((i + 1) / total_steps) * 100
                 if streaming_callback:
-                    streaming_callback(f"Chunk {i + 1} summarized.", MSG_TYPE.MSG_TYPE_STEP_END, {"id": f"chunk_{i+1}", "summary_snippet": chunk_summary[:100]})
+                    streaming_callback(
+                        f"Chunk {i + 1} summarized. Progress: {progress_after:.0f}%", 
+                        MSG_TYPE.MSG_TYPE_STEP_END, 
+                        {"id": f"chunk_{i+1}", "summary_snippet": chunk_summary[:100], "progress": progress_after}
+                    )
             except Exception as e:
                 trace_exception(e)
                 if streaming_callback:
@@ -3045,8 +3061,13 @@ Provide the final aggregated answer in {output_format} format, directly addressi
                 chunk_summaries.append(f"[Error summarizing chunk {i+1}]")
 
         # --- Stage 2: Final Synthesis of All Chunk Summaries ---
+        progress_before_synthesis = (len(chunks) / total_steps) * 100
         if streaming_callback:
-            streaming_callback("Synthesizing all chunk summaries into a final version...", MSG_TYPE.MSG_TYPE_STEP_START, {"id": "final_synthesis"})
+            streaming_callback(
+                "Synthesizing all chunk summaries into a final version...", 
+                MSG_TYPE.MSG_TYPE_STEP_START, 
+                {"id": "final_synthesis", "progress": progress_before_synthesis}
+            )
 
         combined_summaries = "\n\n---\n\n".join(chunk_summaries)
         
@@ -3064,7 +3085,11 @@ Provide the final aggregated answer in {output_format} format, directly addressi
         final_summary = self.generate_text(final_synthesis_prompt, **kwargs)
         
         if streaming_callback:
-            streaming_callback("Final summary synthesized.", MSG_TYPE.MSG_TYPE_STEP_END, {"id": "final_synthesis"})
+            streaming_callback(
+                "Final summary synthesized.", 
+                MSG_TYPE.MSG_TYPE_STEP_END, 
+                {"id": "final_synthesis", "progress": 100}
+            )
 
         return final_summary.strip()
 

lollms_client/lollms_discussion.py

@@ -1180,6 +1180,7 @@ class LollmsDiscussion:
                 "- Key decisions or conclusions reached.\n"
                 "- Important entities, projects, or topics mentioned that are likely to recur.\n"
                 "Format the output as a concise list of bullet points. Be brief and factual. "
+                "Do not repeat information that is already in the User Data Zone or the Memory"
                 "If no new, significant long-term information is present, output the single word: 'NOTHING'."
             )
             
@@ -1251,19 +1252,16 @@ class LollmsDiscussion:
             text_to_count = "\n".join(full_content)
 
         return self.lollmsClient.count_tokens(text_to_count)
-
     def get_context_status(self, branch_tip_id: Optional[str] = None) -> Dict[str, Any]:
         """
         Returns a detailed breakdown of the context size and its components.
 
-        This provides a comprehensive snapshot of the context usage, including the
-        content and token count for each part of the prompt (system prompt, data zones,
-        pruning summary, and message history). The token counts are based on the
-        "lollms_text" export format, which is the format used for pruning calculations.
+        This provides a comprehensive snapshot of the context usage. It accurately calculates
+        the token count of the combined system context (prompt, all data zones, summary)
+        and the message history, reflecting how the `lollms_text` export format works.
 
         Args:
-            branch_tip_id: The ID of the message branch to measure. Defaults
-                           to the active branch.
+            branch_tip_id: The ID of the message branch to measure. Defaults to the active branch.
 
         Returns:
             A dictionary with a detailed breakdown:
@@ -1271,72 +1269,97 @@ class LollmsDiscussion:
                 "max_tokens": int | None,
                 "current_tokens": int,
                 "zones": {
-                    "system_prompt": {"content": str, "tokens": int},
-                    "memory": {"content": str, "tokens": int},
-                    "user_data_zone": {"content": str, "tokens": int},
-                    "discussion_data_zone": {"content": str, "tokens": int},
-                    "personality_data_zone": {"content": str, "tokens": int},
-                    "pruning_summary": {"content": str, "tokens": int},
-                    "message_history": {"content": str, "tokens": int, "message_count": int}
+                    "system_context": {
+                        "content": str,
+                        "tokens": int,
+                        "breakdown": {
+                            "system_prompt": {"content": str, "tokens": int},
+                            "memory": {"content": str, "tokens": int},
+                            ...
+                        }
+                    },
+                    "message_history": {
+                        "content": str,
+                        "tokens": int,
+                        "message_count": int
+                    }
                 }
             }
-            Zones are only included if they contain content.
+            Zones and breakdown components are only included if they contain content.
         """
         result = {
             "max_tokens": self.max_context_size,
             "current_tokens": 0,
             "zones": {}
         }
-        total_tokens = 0
+        tokenizer = self.lollmsClient.count_tokens
 
-        # 1. System Prompt
+        # --- 1. Assemble and Tokenize the Entire System Context Block ---
         system_prompt_text = (self._system_prompt or "").strip()
-        if system_prompt_text:
-            # We count tokens for the full block as it would appear in the prompt
-            full_block = f"!@>system:\n{system_prompt_text}\n"
-            tokens = self.lollmsClient.count_tokens(full_block)
-            result["zones"]["system_prompt"] = {
-                "content": system_prompt_text,
-                "tokens": tokens
-            }
-            total_tokens += tokens
+        data_zone_text = self.get_full_data_zone()
+        pruning_summary_content = (self.pruning_summary or "").strip()
+
+        pruning_summary_block = ""
+        if pruning_summary_content and self.pruning_point_id:
+            pruning_summary_block = f"--- Conversation Summary ---\n{pruning_summary_content}"
+
+        full_system_content_parts = [
+            part for part in [system_prompt_text, data_zone_text, pruning_summary_block] if part
+        ]
+        full_system_content = "\n\n".join(full_system_content_parts).strip()
+
+        if full_system_content:
+            system_block = f"!@>system:\n{full_system_content}\n"
+            system_tokens = tokenizer(system_block)
             
-        # 2. All Data Zones
-        zones_to_process = {
-            "memory": self.memory,
-            "user_data_zone": self.user_data_zone,
-            "discussion_data_zone": self.discussion_data_zone,
-            "personality_data_zone": self.personality_data_zone,
-        }
+            breakdown = {}
+            if system_prompt_text:
+                breakdown["system_prompt"] = {
+                    "content": system_prompt_text,
+                    "tokens": tokenizer(system_prompt_text)
+                }
+
+            memory_text = (self.memory or "").strip()
+            if memory_text:
+                breakdown["memory"] = {
+                    "content": memory_text,
+                    "tokens": tokenizer(memory_text)
+                }
 
-        for name, content in zones_to_process.items():
-            content_text = (content or "").strip()
-            if content_text:
-                # Mimic the formatting from get_full_data_zone for accurate token counting
-                header = f"-- {name.replace('_', ' ').title()} --\n"
-                full_block = f"{header}{content_text}"
-                # In lollms_text format, zones are part of the system message, so we add separators
-                # This counts the standalone block.
-                tokens = self.lollmsClient.count_tokens(full_block)
-                result["zones"][name] = {
-                    "content": content_text,
-                    "tokens": tokens
+            user_data_text = (self.user_data_zone or "").strip()
+            if user_data_text:
+                breakdown["user_data_zone"] = {
+                    "content": user_data_text,
+                    "tokens": tokenizer(user_data_text)
                 }
-                # Note: The 'export' method combines these into one system prompt.
-                # For this breakdown, we count them separately. The total will be a close approximation.
-
-        # 3. Pruning Summary
-        pruning_summary_text = (self.pruning_summary or "").strip()
-        if pruning_summary_text and self.pruning_point_id:
-            full_block = f"!@>system:\n--- Conversation Summary ---\n{pruning_summary_text}\n"
-            tokens = self.lollmsClient.count_tokens(full_block)
-            result["zones"]["pruning_summary"] = {
-                "content": pruning_summary_text,
-                "tokens": tokens
+            
+            discussion_data_text = (self.discussion_data_zone or "").strip()
+            if discussion_data_text:
+                breakdown["discussion_data_zone"] = {
+                    "content": discussion_data_text,
+                    "tokens": tokenizer(discussion_data_text)
+                }
+
+            personality_data_text = (self.personality_data_zone or "").strip()
+            if personality_data_text:
+                breakdown["personality_data_zone"] = {
+                    "content": personality_data_text,
+                    "tokens": tokenizer(personality_data_text)
+                }
+
+            if pruning_summary_content:
+                breakdown["pruning_summary"] = {
+                    "content": pruning_summary_content,
+                    "tokens": tokenizer(pruning_summary_content)
+                }
+
+            result["zones"]["system_context"] = {
+                "content": full_system_content,
+                "tokens": system_tokens,
+                "breakdown": breakdown
             }
-            total_tokens += tokens
-        
-        # 4. Message History
+
+        # --- 2. Assemble and Tokenize the Message History Block ---
         branch_tip_id = branch_tip_id or self.active_branch_id
         messages_text = ""
         message_count = 0
@@ -1344,7 +1367,6 @@ class LollmsDiscussion:
             branch = self.get_branch(branch_tip_id)
             messages_to_render = branch
             
-            # Adjust for pruning to get the active set of messages
             if self.pruning_summary and self.pruning_point_id:
                 pruning_index = -1
                 for i, msg in enumerate(branch):
@@ -1367,19 +1389,18 @@ class LollmsDiscussion:
             message_count = len(messages_to_render)
 
         if messages_text:
-            tokens = self.lollmsClient.count_tokens(messages_text)
+            tokens = tokenizer(messages_text)
             result["zones"]["message_history"] = {
                 "content": messages_text,
                 "tokens": tokens,
                 "message_count": message_count
             }
-            total_tokens += tokens
 
-        # Finalize the total count. This re-calculates based on the actual export format
-        # for maximum accuracy, as combining zones can slightly change tokenization.
+        # --- 3. Finalize the Total Count ---
         result["current_tokens"] = self.count_discussion_tokens("lollms_text", branch_tip_id)
 
         return result
+    
     def switch_to_branch(self, branch_id):
         self.active_branch_id = branch_id
 
@@ -1416,4 +1437,4 @@ class LollmsDiscussion:
         new_metadata = (self.metadata or {}).copy()
         new_metadata[itemname] = item_value
         self.metadata = new_metadata
-        self.commit()
+        self.commit()

{lollms_client-0.29.1.dist-info → lollms_client-0.29.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.29.1
+Version: 0.29.3
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License: Apache Software License
@@ -296,9 +296,22 @@ This example showcases how `lollms-client` allows you to build powerful, knowled
 
 ### Building Stateful Agents with Memory and Data Zones
 
-The latest version of `LollmsDiscussion` introduces powerful features for creating agents that can remember information across conversations. This is achieved through structured data zones and a new `memorize()` method.
+The `LollmsDiscussion` class provides a sophisticated system for creating stateful agents that can remember information across conversations. This is achieved through a layered system of "context zones" that are automatically combined into the AI's system prompt.
 
-Let's build a "Personal Assistant" agent that learns about the user over time.
+#### Understanding the Context Zones
+
+The AI's context is more than just chat history. It's built from several distinct components, each with a specific purpose:
+
+*   **`system_prompt`**: The foundational layer defining the AI's core identity, persona, and primary instructions.
+*   **`memory`**: The AI's long-term, persistent memory. It stores key facts about the user or topics, built up over time using the `memorize()` method.
+*   **`user_data_zone`**: Holds session-specific information about the user's current state or goals (e.g., "User is currently working on 'file.py'").
+*   **`discussion_data_zone`**: Contains state or meta-information about the current conversational task (e.g., "Step 1 of the plan is complete").
+*   **`personality_data_zone`**: A knowledge base or set of rules automatically injected from a `LollmsPersonality`'s `data_source`.
+*   **`pruning_summary`**: An automatic, AI-generated summary of the oldest messages in a very long chat, used to conserve tokens without losing the gist of the early conversation.
+
+The `get_context_status()` method is your window into this system, showing you exactly how these zones are combined and how many tokens they consume.
+
+Let's see this in action with a "Personal Assistant" agent that learns about the user over time.
 
 ```python
 from lollms_client import LollmsClient, LollmsDataManager, LollmsDiscussion, MSG_TYPE
@@ -320,7 +333,8 @@ if not discussion:
         id=discussion_id,
         autosave=True # Important for persistence
     )
-    # Let's preset some user data
+    # Let's preset some data in different zones
+    discussion.system_prompt = "You are a helpful Personal Assistant."
     discussion.user_data_zone = "User's Name: Alex\nUser's Goal: Learn about AI development."
     discussion.commit()
 else:
@@ -331,13 +345,24 @@ def run_chat_turn(prompt: str):
     """Helper function to run a single chat turn and print details."""
     ASCIIColors.cyan(f"\n> User: {prompt}")
 
-    # --- A. Check context status BEFORE the turn ---
+    # --- A. Check context status BEFORE the turn using get_context_status() ---
     ASCIIColors.magenta("\n--- Context Status (Before Generation) ---")
     status = discussion.get_context_status()
-    print(f"Max Tokens: {status.get('max_tokens')}, Current Approx. Tokens: {status.get('current_tokens')}")
-    for zone, data in status.get('zones', {}).items():
-        print(f"  - Zone: {zone}, Tokens: {data['tokens']}")
-        # print(f"    Content: {data['content'][:80]}...") # Uncomment for more detail
+    print(f"Max Tokens: {status.get('max_tokens')}, Current Tokens: {status.get('current_tokens')}")
+    
+    # Print the system context details
+    if 'system_context' in status['zones']:
+        sys_ctx = status['zones']['system_context']
+        print(f"  - System Context Tokens: {sys_ctx['tokens']}")
+        # The 'breakdown' shows the individual zones that were combined
+        for name, content in sys_ctx.get('breakdown', {}).items():
+            print(f"    -> Contains '{name}': {content.split(chr(10))[0]}...")
+
+    # Print the message history details
+    if 'message_history' in status['zones']:
+        msg_hist = status['zones']['message_history']
+        print(f"  - Message History Tokens: {msg_hist['tokens']} ({msg_hist['message_count']} messages)")
+
     print("------------------------------------------")
 
     # --- B. Run the chat ---
@@ -348,7 +373,7 @@ def run_chat_turn(prompt: str):
     )
     print() # Newline after stream
 
-    # --- C. Trigger memorization ---
+    # --- C. Trigger memorization to update the 'memory' zone ---
     ASCIIColors.yellow("\nTriggering memorization process...")
     discussion.memorize()
     discussion.commit() # Save the new memory to the DB
@@ -359,24 +384,30 @@ run_chat_turn("Hi there! Can you recommend a good Python library for building we
 run_chat_turn("That sounds great. By the way, my favorite programming language is Rust, I find its safety features amazing.")
 run_chat_turn("What was my favorite programming language again?")
 
-# --- Final Inspection ---
+# --- Final Inspection of Memory ---
 ASCIIColors.magenta("\n--- Final Context Status ---")
 status = discussion.get_context_status()
-print(f"Max Tokens: {status.get('max_tokens')}, Current Approx. Tokens: {status.get('current_tokens')}")
-for zone, data in status.get('zones', {}).items():
-    print(f"  - Zone: {zone}, Tokens: {data['tokens']}")
-    print(f"    Content: {data['content'][:150].replace(chr(10), ' ')}...")
+print(f"Max Tokens: {status.get('max_tokens')}, Current Tokens: {status.get('current_tokens')}")
+if 'system_context' in status['zones']:
+    sys_ctx = status['zones']['system_context']
+    print(f"  - System Context Tokens: {sys_ctx['tokens']}")
+    for name, content in sys_ctx.get('breakdown', {}).items():
+        # Print the full content of the memory zone to verify it was updated
+        if name == 'memory':
+            ASCIIColors.yellow(f"    -> Full '{name}' content:\n{content}")
+        else:
+            print(f"    -> Contains '{name}': {content.split(chr(10))[0]}...")
 print("------------------------------------------")
 
 ```
 
 #### How it Works:
 
-1.  **Persistence:** The `LollmsDataManager` and `autosave=True` ensure that all changes to the discussion, including the data zones and memory, are saved to the `my_assistant.db` file. When you re-run the script, it loads the previous state.
-2.  **`user_data_zone`:** We pre-filled this zone with basic user info. This context is provided to the AI in every turn.
-3.  **`get_context_status()`:** Before each generation, we call this method to get a detailed breakdown of the prompt. This is excellent for debugging and understanding how the context window is being used.
-4.  **`memorize()`:** After the user mentions their favorite language, `memorize()` is called. The LLM analyzes the last turn, identifies this new, important fact ("user's favorite language is Rust"), and appends it to the `discussion.memory` field.
-5.  **Recall:** In the final turn, when asked to recall the favorite language, the AI has access to the `memory` zone and can correctly answer "Rust", even if that information had scrolled out of the recent conversation history. This demonstrates true long-term memory.
+1.  **Persistence & Initialization:** The `LollmsDataManager` saves and loads the discussion. We initialize the `system_prompt` and `user_data_zone` to provide initial context.
+2.  **`get_context_status()`:** Before each generation, we call this method. The output shows a `system_context` block with a token count for all combined zones and a `breakdown` field that lets us see the content of each individual zone that contributed to it.
+3.  **`memorize()`:** After the user mentions their favorite language, `memorize()` is called. The LLM analyzes the last turn, identifies this new, important fact, and appends it to the `discussion.memory` zone.
+4.  **Recall:** In the final turn, when asked to recall the favorite language, the AI has access to the updated `memory` content within its system context and can correctly answer "Rust". This demonstrates true long-term, stateful memory.
+
 
 ## Documentation
 
@@ -922,33 +953,54 @@ discussion.commit() # Save the updated memory to the database
 ```
 
 #### `get_context_status()`
-Provides a detailed, real-time breakdown of the current prompt context, showing exactly what will be sent to the model and how many tokens each part occupies.
 
-- **Return Value:** A dictionary containing the `max_tokens`, `current_tokens`, and a `zones` dictionary with the content and token count for each component.
-- **Use Case:** Essential for debugging context issues, understanding token usage, and visualizing how different data zones contribute to the final prompt.
+Provides a detailed, real-time breakdown of the current prompt context, showing exactly what will be sent to the model and how many tokens each major component occupies. This is crucial for debugging context issues and understanding token usage.
+
+The method accurately reflects the structure of the `lollms_text` format, where all system-level instructions (the main prompt, all data zones, and the pruning summary) are combined into a single system block.
+
+-   **Return Value:** A dictionary containing:
+    -   `max_tokens`: The configured maximum token limit for the discussion.
+    -   `current_tokens`: The total, most accurate token count for the entire prompt, calculated using the same logic as the `chat()` method.
+    -   `zones`: A dictionary with up to two keys:
+        -   **`system_context`**: Present if there is any system-level content. It contains:
+            -   `tokens`: The total token count for the **entire combined system block** (e.g., `!@>system:\n...\n`).
+            -   `content`: The full string content of the system block, showing exactly how all zones are merged.
+            -   `breakdown`: A sub-dictionary showing the raw text of each individual component (e.g., `system_prompt`, `memory`, `user_data_zone`) that was used to build the `content`.
+        -   **`message_history`**: Present if there are messages in the branch. It contains:
+            -   `tokens`: The total token count for the message history part of the prompt.
+            -   `content`: The full string of the formatted message history.
+            -   `message_count`: The number of messages included in the history.
+
+-   **Use Case:** Essential for debugging context issues, visualizing how different data zones contribute to the final prompt, and monitoring token consumption.
 
 ```python
 import json
 
+# Assuming 'discussion' is an LollmsDiscussion object with some data
+discussion.system_prompt = "You are a helpful AI."
+discussion.user_data_zone = "User is named Bob."
+discussion.add_message(sender="user", content="Hello!")
+discussion.add_message(sender="assistant", content="Hi Bob!")
+
 status = discussion.get_context_status()
 print(json.dumps(status, indent=2))
 
 # Expected Output Structure:
 # {
-#   "max_tokens": 8192,
-#   "current_tokens": 521,
+#   "max_tokens": null,
+#   "current_tokens": 46,
 #   "zones": {
-#     "system_prompt": {
-#       "content": "You are a helpful assistant.",
-#       "tokens": 12
-#     },
-#     "memory": {
-#       "content": "User's favorite color is blue.",
-#       "tokens": 15
+#     "system_context": {
+#       "content": "You are a helpful AI.\n\n-- User Data Zone --\nUser is named Bob.",
+#       "tokens": 25,
+#       "breakdown": {
+#         "system_prompt": "You are a helpful AI.",
+#         "user_data_zone": "User is named Bob."
+#       }
 #     },
 #     "message_history": {
-#       "content": "!@>user:\nHi there!\n!@>assistant:\nHello! How can I help?\n",
-#       "tokens": 494,
+#       "content": "!@>user:\nHello!\n!@>assistant:\nHi Bob!\n",
+#       "tokens": 21,
 #       "message_count": 2
 #     }
 #   }

{lollms_client-0.29.1.dist-info → lollms_client-0.29.3.dist-info}/RECORD

@@ -29,10 +29,10 @@ examples/mcp_examples/openai_mcp.py,sha256=7IEnPGPXZgYZyiES_VaUbQ6viQjenpcUxGiHE
 examples/mcp_examples/run_remote_mcp_example_v2.py,sha256=bbNn93NO_lKcFzfIsdvJJijGx2ePFTYfknofqZxMuRM,14626
 examples/mcp_examples/run_standard_mcp_example.py,sha256=GSZpaACPf3mDPsjA8esBQVUsIi7owI39ca5avsmvCxA,9419
 examples/test_local_models/local_chat.py,sha256=slakja2zaHOEAUsn2tn_VmI4kLx6luLBrPqAeaNsix8,456
-lollms_client/__init__.py,sha256=K9y45gf5gbAd4WDNX6Lxmax_hJCXmRvZLMSgaL-XVys,1147
+lollms_client/__init__.py,sha256=5WRehZnsWKKGP_lLPJ_PCHk1NMQBGRcezXExtvvtKzg,1147
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=KfeOs-xt3QZCQUsHCsPi2Zh_ZpfmEmMhJLR2sMiP27Y,170420
-lollms_client/lollms_discussion.py,sha256=UzDYZmBqV2cZISumg3r6HMj3Pmc2uOU4ZQ42eB4Uovs,67363
+lollms_client/lollms_core.py,sha256=ABfUq13P_zo_qpLwHNhtvzmiA1nHZyqbBLKoaVECNi4,171407
+lollms_client/lollms_discussion.py,sha256=zdm02lzd3cQNPaZfJ3zCa8yQTYw7mogqWk1cve3UOao,67697
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
 lollms_client/lollms_llm_binding.py,sha256=cU0cmxZfIrp-ofutbRLx7W_59dxzPXpU-vO98MqVnQA,14788
 lollms_client/lollms_mcp_binding.py,sha256=0rK9HQCBEGryNc8ApBmtOlhKE1Yfn7X7xIQssXxS2Zc,8933
@@ -53,7 +53,7 @@ lollms_client/llm_bindings/grok/__init__.py,sha256=5tIf3348RgAEaSp6FdG-LM9N8R7aR
 lollms_client/llm_bindings/groq/__init__.py,sha256=zyWKM78qHwSt5g0Bb8Njj7Jy8CYuLMyplx2maOKFFpg,12218
 lollms_client/llm_bindings/hugging_face_inference_api/__init__.py,sha256=PxgeRqT8dpa9GZoXwtSncy9AUgAN2cDKrvp_nbaWq0E,14027
 lollms_client/llm_bindings/litellm/__init__.py,sha256=pNkwyRPeENvTM4CDh6Pj3kQfxHfhX2pvXhGJDjKjp30,12340
-lollms_client/llm_bindings/llamacpp/__init__.py,sha256=XcccmAASfNwcOwwjKjUJAaN5NDHthU9CEroDPqlG6uM,63778
+lollms_client/llm_bindings/llamacpp/__init__.py,sha256=4cotP3cYhiA0501UnGVljlEBBVatNyfIyrZsHUPJk24,63878
 lollms_client/llm_bindings/lollms/__init__.py,sha256=scGHEKzlGX5fw2XwefVicsf28GrwgN3wU5nl4EPJ_Sk,24424
 lollms_client/llm_bindings/lollms_webui/__init__.py,sha256=Thoq3PJR2e03Y2Kd_FBb-DULJK0zT5-2ID1YIJLcPlw,17864
 lollms_client/llm_bindings/mistral/__init__.py,sha256=624Gr462yBh52ttHFOapKgJOn8zZ1vZcTEcC3i4FYt8,12750
@@ -92,8 +92,8 @@ lollms_client/tts_bindings/piper_tts/__init__.py,sha256=0IEWG4zH3_sOkSb9WbZzkeV5
 lollms_client/tts_bindings/xtts/__init__.py,sha256=FgcdUH06X6ZR806WQe5ixaYx0QoxtAcOgYo87a2qxYc,18266
 lollms_client/ttv_bindings/__init__.py,sha256=UZ8o2izQOJLQgtZ1D1cXoNST7rzqW22rL2Vufc7ddRc,3141
 lollms_client/ttv_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client-0.29.1.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-0.29.1.dist-info/METADATA,sha256=1-FaAIFYCrxPe780f6-SfZcmN3GTTjYggjW5qrZy3xU,44176
-lollms_client-0.29.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-0.29.1.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
-lollms_client-0.29.1.dist-info/RECORD,,
+lollms_client-0.29.3.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-0.29.3.dist-info/METADATA,sha256=wWn-0CasMd51exqHdQXynjYTcPtYVSiycyCGMv7aTII,47847
+lollms_client-0.29.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-0.29.3.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
+lollms_client-0.29.3.dist-info/RECORD,,