praisonaiagents 0.0.153__py3-none-any.whl → 0.0.155__py3-none-any.whl

praisonaiagents/agent/agent.py

@@ -46,6 +46,21 @@ if TYPE_CHECKING:
     from ..handoff import Handoff
 
 class Agent:
+    @classmethod
+    def _configure_logging(cls):
+        """Configure logging settings once for all agent instances."""
+        # Configure logging to suppress unwanted outputs
+        logging.getLogger("litellm").setLevel(logging.WARNING)
+        
+        # Allow httpx logging when LOGLEVEL=debug, otherwise suppress it
+        loglevel = os.environ.get('LOGLEVEL', 'INFO').upper()
+        if loglevel == 'DEBUG':
+            logging.getLogger("httpx").setLevel(logging.INFO)
+            logging.getLogger("httpcore").setLevel(logging.INFO)
+        else:
+            logging.getLogger("httpx").setLevel(logging.WARNING)
+            logging.getLogger("httpcore").setLevel(logging.WARNING)
+    
     def _generate_tool_definition(self, function_name):
         """
         Generate a tool definition from a function name by inspecting the function.
@@ -332,17 +347,10 @@ class Agent:
         if all(x is None for x in [name, role, goal, backstory, instructions]):
             raise ValueError("At least one of name, role, goal, backstory, or instructions must be provided")
 
-        # Configure logging to suppress unwanted outputs
-        logging.getLogger("litellm").setLevel(logging.WARNING)
-        
-        # Allow httpx logging when LOGLEVEL=debug, otherwise suppress it
-        loglevel = os.environ.get('LOGLEVEL', 'INFO').upper()
-        if loglevel == 'DEBUG':
-            logging.getLogger("httpx").setLevel(logging.INFO)
-            logging.getLogger("httpcore").setLevel(logging.INFO)
-        else:
-            logging.getLogger("httpx").setLevel(logging.WARNING)
-            logging.getLogger("httpcore").setLevel(logging.WARNING)
+        # Configure logging only once at the class level
+        if not hasattr(Agent, '_logging_configured'):
+            Agent._configure_logging()
+            Agent._logging_configured = True
 
         # If instructions are provided, use them to set role, goal, and backstory
         if instructions:
@@ -383,6 +391,7 @@ class Agent:
                     llm_config['base_url'] = base_url
                     if api_key:
                         llm_config['api_key'] = api_key
+                    llm_config['metrics'] = metrics
                     self.llm_instance = LLM(**llm_config)
                 else:
                     # Create LLM with model string and base_url
@@ -390,7 +399,8 @@ class Agent:
                     self.llm_instance = LLM(
                         model=model_name,
                         base_url=base_url,
-                        api_key=api_key
+                        api_key=api_key,
+                        metrics=metrics
                     )
                 self._using_custom_llm = True
             except ImportError as e:
@@ -406,6 +416,9 @@ class Agent:
                 if api_key and 'api_key' not in llm:
                     llm = llm.copy()
                     llm['api_key'] = api_key
+                # Add metrics parameter
+                llm = llm.copy()
+                llm['metrics'] = metrics
                 self.llm_instance = LLM(**llm)  # Pass all dict items as kwargs
                 self._using_custom_llm = True
             except ImportError as e:
@@ -421,6 +434,7 @@ class Agent:
                 llm_params = {'model': llm}
                 if api_key:
                     llm_params['api_key'] = api_key
+                llm_params['metrics'] = metrics
                 self.llm_instance = LLM(**llm_params)
                 self._using_custom_llm = True
                 
@@ -474,7 +488,7 @@ class Agent:
         self.reflect_prompt = reflect_prompt
         # Use the same model selection logic for reflect_llm
         self.reflect_llm = reflect_llm or os.getenv('OPENAI_MODEL_NAME', 'gpt-4o')
-        self.console = Console()  # Create a single console instance for the agent
+        self._console = None  # Lazy load console when needed
         
         # Initialize system prompt
         self.system_prompt = f"""{self.backstory}\n
@@ -482,8 +496,8 @@ Your Role: {self.role}\n
 Your Goal: {self.goal}
         """
 
-        # Generate unique IDs
-        self.agent_id = str(uuid.uuid4())
+        # Lazy generate unique ID when needed
+        self._agent_id = None
 
         # Store user_id
         self.user_id = user_id or "praison"
@@ -494,6 +508,14 @@ Your Goal: {self.goal}
         self.max_guardrail_retries = max_guardrail_retries
         self._guardrail_fn = None
         self._setup_guardrail()
+        
+        # Cache for system prompts and formatted tools
+        # Note: In single-threaded usage (common case), these are safe
+        # For multi-threaded usage, consider using threading.Lock
+        self._system_prompt_cache = {}
+        self._formatted_tools_cache = {}
+        # Limit cache size to prevent unbounded growth
+        self._max_cache_size = 100
 
         # Process handoffs and convert them to tools
         self.handoffs = handoffs if handoffs else []
@@ -502,16 +524,23 @@ Your Goal: {self.goal}
         # Check if knowledge parameter has any values
         if not knowledge:
             self.knowledge = None
+            self._knowledge_sources = None
+            self._knowledge_processed = True  # No knowledge to process
         else:
-            # Initialize Knowledge with provided or default config
-            from praisonaiagents.knowledge import Knowledge
-            self.knowledge = Knowledge(knowledge_config or None)
-            
-            # Handle knowledge
-            if knowledge:
-                for source in knowledge:
-                    self._process_knowledge(source)
+            # Store knowledge sources for lazy processing
+            self._knowledge_sources = knowledge
+            self._knowledge_processed = False
+            self._knowledge_config = knowledge_config
+            self.knowledge = None  # Will be initialized on first use
 
+    @property
+    def console(self):
+        """Lazily initialize Rich Console only when needed."""
+        if self._console is None:
+            from rich.console import Console
+            self._console = Console()
+        return self._console
+    
     @property
     def _openai_client(self):
         """Lazily initialize OpenAI client only when needed."""
@@ -530,6 +559,14 @@ Your Goal: {self.goal}
                     raise e
         return self.__openai_client
 
+    @property
+    def agent_id(self):
+        """Lazily generate agent ID when first accessed."""
+        if self._agent_id is None:
+            import uuid
+            self._agent_id = str(uuid.uuid4())
+        return self._agent_id
+    
     @property
     def llm_model(self):
         """Unified property to get the LLM model regardless of configuration type.
@@ -548,6 +585,19 @@ Your Goal: {self.goal}
             # Default fallback
             return "gpt-4o"
 
+    def _ensure_knowledge_processed(self):
+        """Ensure knowledge is initialized and processed when first accessed."""
+        if not self._knowledge_processed and self._knowledge_sources:
+            # Initialize Knowledge with provided or default config
+            from praisonaiagents.knowledge import Knowledge
+            self.knowledge = Knowledge(self._knowledge_config or None)
+            
+            # Process all knowledge sources
+            for source in self._knowledge_sources:
+                self._process_knowledge(source)
+            
+            self._knowledge_processed = True
+    
     def _process_knowledge(self, knowledge_item):
         """Process and store knowledge from a file path, URL, or string."""
         try:
@@ -734,6 +784,23 @@ Your Goal: {self.goal}
         
         return current_response
     
+    def _get_tools_cache_key(self, tools):
+        """Generate a cache key for tools list."""
+        if tools is None:
+            return "none"
+        if not tools:
+            return "empty"
+        # Create a simple hash based on tool names
+        tool_names = []
+        for tool in tools:
+            if callable(tool) and hasattr(tool, '__name__'):
+                tool_names.append(tool.__name__)
+            elif isinstance(tool, dict) and 'function' in tool and 'name' in tool['function']:
+                tool_names.append(tool['function']['name'])
+            elif isinstance(tool, str):
+                tool_names.append(tool)
+        return "|".join(sorted(tool_names))
+    
     def _build_system_prompt(self, tools=None):
         """Build the system prompt with tool information.
         
@@ -745,6 +812,13 @@ Your Goal: {self.goal}
         """
         if not self.use_system_prompt:
             return None
+        
+        # Check cache first
+        tools_key = self._get_tools_cache_key(tools)
+        cache_key = f"{self.role}:{self.goal}:{tools_key}"
+        
+        if cache_key in self._system_prompt_cache:
+            return self._system_prompt_cache[cache_key]
             
         system_prompt = f"""{self.backstory}\n
 Your Role: {self.role}\n
@@ -779,6 +853,10 @@ Your Goal: {self.goal}"""
             if tool_names:
                 system_prompt += f"\n\nYou have access to the following tools: {', '.join(tool_names)}. Use these tools when appropriate to help complete your tasks. Always use tools when they can help provide accurate information or perform actions."
         
+        # Cache the generated system prompt
+        # Simple cache size limit to prevent unbounded growth
+        if len(self._system_prompt_cache) < self._max_cache_size:
+            self._system_prompt_cache[cache_key] = system_prompt
         return system_prompt
 
     def _build_messages(self, prompt, temperature=0.2, output_json=None, output_pydantic=None, tools=None):
@@ -854,6 +932,11 @@ Your Goal: {self.goal}"""
         
         if not tools:
             return []
+        
+        # Check cache first
+        tools_key = self._get_tools_cache_key(tools)
+        if tools_key in self._formatted_tools_cache:
+            return self._formatted_tools_cache[tools_key]
             
         formatted_tools = []
         for tool in tools:
@@ -903,7 +986,11 @@ Your Goal: {self.goal}"""
             except (TypeError, ValueError) as e:
                 logging.error(f"Tools are not JSON serializable: {e}")
                 return []
-                
+        
+        # Cache the formatted tools
+        # Simple cache size limit to prevent unbounded growth
+        if len(self._formatted_tools_cache) < self._max_cache_size:
+            self._formatted_tools_cache[tools_key] = formatted_tools
         return formatted_tools
 
     def generate_task(self) -> 'Task':
@@ -1274,6 +1361,9 @@ Your Goal: {self.goal}"""
         if stream is None:
             stream = self.stream
         # Search for existing knowledge if any knowledge is provided
+        if self._knowledge_sources and not self._knowledge_processed:
+            self._ensure_knowledge_processed()
+        
         if self.knowledge:
             search_results = self.knowledge.search(prompt, agent_id=self.agent_id)
             if search_results:
@@ -1632,6 +1722,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 tools = self.tools
 
             # Search for existing knowledge if any knowledge is provided
+            if self._knowledge_sources and not self._knowledge_processed:
+                self._ensure_knowledge_processed()
+            
             if self.knowledge:
                 search_results = self.knowledge.search(prompt, agent_id=self.agent_id)
                 if search_results:
@@ -2025,6 +2118,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             if self._using_custom_llm:
                 # Handle knowledge search
                 actual_prompt = prompt
+                if self._knowledge_sources and not self._knowledge_processed:
+                    self._ensure_knowledge_processed()
+                
                 if self.knowledge:
                     search_results = self.knowledge.search(prompt, agent_id=self.agent_id)
                     if search_results:
@@ -2104,6 +2200,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
                 # For OpenAI-style models, implement proper streaming without display
                 # Handle knowledge search
                 actual_prompt = prompt
+                if self._knowledge_sources and not self._knowledge_processed:
+                    self._ensure_knowledge_processed()
+                
                 if self.knowledge:
                     search_results = self.knowledge.search(prompt, agent_id=self.agent_id)
                     if search_results:

praisonaiagents/knowledge/knowledge.py

@@ -59,11 +59,11 @@ class MongoDBMemory:
         self.collection_name = self.vector_store_config.get("collection", "knowledge_base")
         self.use_vector_search = self.vector_store_config.get("use_vector_search", True)
         
+        # Initialize embedding model before MongoDB to ensure embedding_model_name is available
+        self._init_embedding_model()
+        
         # Initialize MongoDB client
         self._init_mongodb()
-        
-        # Initialize embedding model
-        self._init_embedding_model()
     
     def _init_mongodb(self):
         """Initialize MongoDB client and collection."""
@@ -159,7 +159,14 @@ class MongoDBMemory:
                 }
             }
             
-            self.collection.create_search_index(vector_index_def, "vector_index")
+            # Use SearchIndexModel for PyMongo 4.6+ compatibility
+            try:
+                from pymongo.operations import SearchIndexModel
+                search_index_model = SearchIndexModel(definition=vector_index_def, name="vector_index")
+                self.collection.create_search_index(search_index_model)
+            except ImportError:
+                # Fallback for older PyMongo versions
+                self.collection.create_search_index(vector_index_def, "vector_index")
             
         except Exception as e:
             logging.warning(f"Could not create vector search index: {e}")

praisonaiagents/llm/llm.py

@@ -260,6 +260,7 @@ class LLM:
         self.max_reflect = extra_settings.get('max_reflect', 3)
         self.min_reflect = extra_settings.get('min_reflect', 1)
         self.reasoning_steps = extra_settings.get('reasoning_steps', False)
+        self.metrics = extra_settings.get('metrics', False)
         
         # Token tracking
         self.last_token_metrics: Optional[TokenMetrics] = None
@@ -954,7 +955,8 @@ class LLM:
                         final_response = resp
                         
                         # Track token usage
-                        self._track_token_usage(final_response, model)
+                        if self.metrics:
+                            self._track_token_usage(final_response, model)
                         
                         # Execute callbacks and display based on verbose setting
                         generation_time_val = time.time() - current_time
@@ -1135,7 +1137,8 @@ class LLM:
                                             response_text = response_content if response_content is not None else ""
                                             
                                             # Track token usage
-                                            self._track_token_usage(final_response, self.model)
+                                            if self.metrics:
+                                                self._track_token_usage(final_response, self.model)
                                         
                                         # Execute callbacks and display based on verbose setting
                                         if verbose and not interaction_displayed:
@@ -1284,7 +1287,8 @@ class LLM:
                                 response_text = response_content if response_content is not None else ""
                                 
                                 # Track token usage
-                                self._track_token_usage(final_response, self.model)
+                                if self.metrics:
+                                    self._track_token_usage(final_response, self.model)
                             
                             # Execute callbacks and display based on verbose setting
                             if verbose and not interaction_displayed:
@@ -2887,6 +2891,9 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
         if not TokenMetrics or not _token_collector:
             return None
         
+        # Note: metrics check moved to call sites for performance
+        # This method should only be called when self.metrics=True
+        
         try:
             usage = response.get("usage", {})
             if not usage:

praisonaiagents/mcp/mcp_http_stream.py

@@ -5,12 +5,14 @@ over HTTP Stream transport, implementing the Streamable HTTP transport protocol.
 """
 
 import asyncio
+import atexit
 import logging
 import threading
 import inspect
 import json
 import time
 import uuid
+import weakref
 from typing import List, Dict, Any, Optional, Callable, Iterable, Union
 from urllib.parse import urlparse, urljoin
 
@@ -25,6 +27,10 @@ logger = logging.getLogger("mcp-http-stream")
 # Global event loop for async operations
 _event_loop = None
 
+# Global registry of active clients for cleanup
+_active_clients = weakref.WeakSet()
+_cleanup_registered = False
+
 def get_event_loop():
     """Get or create a global event loop."""
     global _event_loop
@@ -34,6 +40,31 @@ def get_event_loop():
     return _event_loop
 
 
+def _cleanup_all_clients():
+    """Clean up all active clients at program exit."""
+    if not _active_clients:
+        return
+    
+    # Create a copy to avoid modification during iteration
+    clients_to_cleanup = list(_active_clients)
+    
+    for client in clients_to_cleanup:
+        try:
+            if hasattr(client, '_force_cleanup'):
+                client._force_cleanup()
+        except Exception:
+            # Ignore exceptions during cleanup
+            pass
+
+
+def _register_cleanup():
+    """Register the cleanup function to run at program exit."""
+    global _cleanup_registered
+    if not _cleanup_registered:
+        atexit.register(_cleanup_all_clients)
+        _cleanup_registered = True
+
+
 class HTTPStreamMCPTool:
     """A wrapper for an MCP tool that can be used with praisonaiagents."""
     
@@ -388,6 +419,7 @@ class HTTPStreamMCPClient:
         self.session = None
         self.tools = []
         self.transport = None
+        self._closed = False
         
         # Set up logging
         if debug:
@@ -396,6 +428,10 @@ class HTTPStreamMCPClient:
             # Set to WARNING by default to hide INFO messages
             logger.setLevel(logging.WARNING)
         
+        # Register this client for cleanup and setup exit handler
+        _active_clients.add(self)
+        _register_cleanup()
+        
         self._initialize()
         
     def _initialize(self):
@@ -456,6 +492,10 @@ class HTTPStreamMCPClient:
                 timeout=self.timeout
             )
             tools.append(wrapper)
+        
+        # Set up cleanup finalizer now that transport and session are created
+        self._finalizer = weakref.finalize(self, self._static_cleanup, 
+                                         self.transport, self._session_context)
             
         return tools
     
@@ -477,30 +517,97 @@ class HTTPStreamMCPClient:
     
     async def aclose(self):
         """Async cleanup method to close all resources."""
-        if self.transport:
-            await self.transport.__aexit__(None, None, None)
-        if hasattr(self, '_session_context') and self._session_context:
-            await self._session_context.__aexit__(None, None, None)
+        if self._closed:
+            return
+        
+        self._closed = True
+        
+        try:
+            if hasattr(self, '_session_context') and self._session_context:
+                await self._session_context.__aexit__(None, None, None)
+        except Exception:
+            pass
+        
+        try:
+            if self.transport:
+                await self.transport.__aexit__(None, None, None)
+        except Exception:
+            pass
     
     def close(self):
         """Synchronous cleanup method to close all resources."""
-        if hasattr(self, 'transport') and self.transport and not getattr(self.transport, '_closed', False):
-            try:
-                # Use the global event loop for non-blocking cleanup
-                loop = get_event_loop()
-                if not loop.is_closed():
-                    # Schedule cleanup without blocking
-                    asyncio.run_coroutine_threadsafe(self.aclose(), loop)
-            except Exception:
-                # Silently ignore cleanup errors to avoid impacting performance
-                pass
+        if self._closed:
+            return
+            
+        try:
+            # Use the global event loop for non-blocking cleanup
+            loop = get_event_loop()
+            if not loop.is_closed():
+                # Schedule cleanup without blocking - add callback for fallback
+                future = asyncio.run_coroutine_threadsafe(self.aclose(), loop)
+                
+                # Add a completion callback for fallback cleanup if async fails
+                def _cleanup_callback(fut):
+                    try:
+                        fut.result()  # This will raise if aclose() failed
+                    except Exception:
+                        # If async cleanup failed, try force cleanup
+                        try:
+                            self._force_cleanup()
+                        except Exception:
+                            pass
+                
+                future.add_done_callback(_cleanup_callback)
+            else:
+                # Event loop is closed, use force cleanup immediately
+                self._force_cleanup()
+        except Exception:
+            # If async scheduling fails, try force cleanup
+            self._force_cleanup()
+    
+    def _force_cleanup(self):
+        """Force cleanup of resources synchronously (for emergencies)."""
+        if self._closed:
+            return
+            
+        self._closed = True
+        
+        # Force close transport session if it exists
+        try:
+            if self.transport and hasattr(self.transport, '_session') and self.transport._session:
+                session = self.transport._session
+                if not session.closed:
+                    # Force close the aiohttp session
+                    if hasattr(session, '_connector') and session._connector:
+                        try:
+                            # Close connector directly
+                            session._connector.close()
+                        except Exception:
+                            pass
+        except Exception:
+            pass
+    
+    @staticmethod
+    def _static_cleanup(transport, session_context):
+        """Static cleanup method for weakref finalizer."""
+        try:
+            # This is called by weakref finalizer, so we can't do async operations
+            # Just ensure any session is closed if possible
+            if transport and hasattr(transport, '_session') and transport._session:
+                session = transport._session
+                if not session.closed and hasattr(session, '_connector'):
+                    try:
+                        session._connector.close()
+                    except Exception:
+                        pass
+        except Exception:
+            pass
     
     def __del__(self):
         """Cleanup when object is garbage collected."""
         try:
-            # Simple, lightweight cleanup
-            if hasattr(self, 'transport') and self.transport:
-                self.close()
+            if not self._closed:
+                self._force_cleanup()
         except Exception:
             # Never raise exceptions in __del__
             pass

praisonaiagents/memory/memory.py

@@ -377,8 +377,16 @@ class Memory:
             
             # Create vector indexes for both short and long term collections
             try:
-                self.mongo_short_term.create_search_index(vector_index_def, "vector_index")
-                self.mongo_long_term.create_search_index(vector_index_def, "vector_index")
+                # Use SearchIndexModel for PyMongo 4.6+ compatibility
+                try:
+                    from pymongo.operations import SearchIndexModel
+                    search_index_model = SearchIndexModel(definition=vector_index_def, name="vector_index")
+                    self.mongo_short_term.create_search_index(search_index_model)
+                    self.mongo_long_term.create_search_index(search_index_model)
+                except ImportError:
+                    # Fallback for older PyMongo versions
+                    self.mongo_short_term.create_search_index(vector_index_def, "vector_index")
+                    self.mongo_long_term.create_search_index(vector_index_def, "vector_index")
                 self._log_verbose("Vector search indexes created successfully")
             except Exception as e:
                 self._log_verbose(f"Could not create vector search indexes: {e}", logging.WARNING)

praisonaiagents/tools/mongodb_tools.py

@@ -335,7 +335,14 @@ class MongoDBTools:
             }
             
             try:
-                collection.create_search_index(index_definition, index_name)
+                # Use SearchIndexModel for PyMongo 4.6+ compatibility
+                try:
+                    from pymongo.operations import SearchIndexModel
+                    search_index_model = SearchIndexModel(definition=index_definition, name=index_name)
+                    collection.create_search_index(search_index_model)
+                except ImportError:
+                    # Fallback for older PyMongo versions
+                    collection.create_search_index(index_definition, index_name)
                 return {
                     "success": True,
                     "message": f"Vector search index '{index_name}' created successfully"

{praisonaiagents-0.0.153.dist-info → praisonaiagents-0.0.155.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.153
+Version: 0.0.155
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Python: >=3.10

{praisonaiagents-0.0.153.dist-info → praisonaiagents-0.0.155.dist-info}/RECORD

@@ -6,7 +6,7 @@ praisonaiagents/flow_display.py,sha256=E84J_H3h8L-AqL_F1JzEUInQYdjmIEuNL1LZr4__H
 praisonaiagents/main.py,sha256=NuAmE-ZrH4X0O9ysNA2AfxEQ8APPssO_ZR_f7h97QOo,17370
 praisonaiagents/session.py,sha256=FHWButPBaFGA4x1U_2gImroQChHnFy231_aAa_n5KOQ,20364
 praisonaiagents/agent/__init__.py,sha256=KBqW_augD-HcaV3FL88gUmhDCpwnSTavGENi7RqneTo,505
-praisonaiagents/agent/agent.py,sha256=VXRMG1xwog1x_YP71AXvFT7p5Ik4kXU0016AEQMzdHc,143988
+praisonaiagents/agent/agent.py,sha256=sJ_mMp2v8ZCok32G-wzO71HEtjuBqlrEPttUXQgiui8,148240
 praisonaiagents/agent/context_agent.py,sha256=zNI2Waghn5eo8g3QM1Dc7ZNSr2xw41D87GIK81FjW-Y,107489
 praisonaiagents/agent/handoff.py,sha256=Saq0chqfvC6Zf5UbXvmctybbehqnotrXn72JsS-76Q0,13099
 praisonaiagents/agent/image_agent.py,sha256=xKDhW8T1Y3e15lQpY6N2pdvBNJmAoWDibJa4BYa-Njs,10205
@@ -19,18 +19,18 @@ praisonaiagents/guardrails/guardrail_result.py,sha256=2K1WIYRyT_s1H6vBGa-7HEHzXC
 praisonaiagents/guardrails/llm_guardrail.py,sha256=czdOIoY-3PZOchX317tz4O2h2WYE42Ua4tqVzyuoNlI,4859
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
-praisonaiagents/knowledge/knowledge.py,sha256=OzK81oA6sjk9nAUWphS7AkXxvalrv2AHB4FtHjzYgxI,30115
+praisonaiagents/knowledge/knowledge.py,sha256=tog38b0SjFMoLuFBo0M1zHl9Dzzxa9YRv9FO7OZSpns,30587
 praisonaiagents/llm/__init__.py,sha256=SqdU1pRqPrR6jZeWYyDeTvmZKCACywk0v4P0k5Fuowk,1107
-praisonaiagents/llm/llm.py,sha256=HFN5pJUogqeCYcDk1b4JJe6VXbEFMXyQBZ-byKaObVQ,176229
+praisonaiagents/llm/llm.py,sha256=155R1XHZLSDZsq67Hmglwc4N_SE2gKgid0KCFYNX3ww,176594
 praisonaiagents/llm/model_capabilities.py,sha256=cxOvZcjZ_PIEpUYKn3S2FMyypfOSfbGpx4vmV7Y5vhI,3967
 praisonaiagents/llm/model_router.py,sha256=Jy2pShlkLxqXF3quz-MRB3-6L9vaUSgUrf2YJs_Tsg0,13995
 praisonaiagents/llm/openai_client.py,sha256=3EVjIs3tnBNFDy_4ZxX9DJVq54kS0FMm38m5Gkpun7U,57234
 praisonaiagents/mcp/__init__.py,sha256=ibbqe3_7XB7VrIcUcetkZiUZS1fTVvyMy_AqCSFG8qc,240
 praisonaiagents/mcp/mcp.py,sha256=ChaSwLCcFBB9b8eNuj0DoKbK1EqpyF1T_7xz0FX-5-A,23264
-praisonaiagents/mcp/mcp_http_stream.py,sha256=3lCzZWdY6_X6fgQjQWDsB9_bB2vxdKsUs2PFmNt98Pw,19763
+praisonaiagents/mcp/mcp_http_stream.py,sha256=TDFWMJMo8VqLXtXCW73REpmkU3t9n7CAGMa9b4dhI-c,23366
 praisonaiagents/mcp/mcp_sse.py,sha256=KO10tAgZ5vSKeRhkJIZcdJ0ZmhRybS39i1KybWt4D7M,9128
 praisonaiagents/memory/__init__.py,sha256=aEFdhgtTqDdMhc_JCWM-f4XI9cZIj7Wz5g_MUa-0amg,397
-praisonaiagents/memory/memory.py,sha256=HjanP8sSi91wifvPkQDH40uGYdDZPOeir29fCu6y-b8,64584
+praisonaiagents/memory/memory.py,sha256=B2DMuvvr4W_EnrpoN16K73qSqYdduqhMcV8ASzyh2L8,65116
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=wXKZ2Z26vB9osmVbD5xqkUlUQRvWEpvL8j9hiuiHrQ0,78246
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
@@ -53,7 +53,7 @@ praisonaiagents/tools/duckduckgo_tools.py,sha256=ynlB5ZyWfHYjUq0JZXH12TganqTihgD
 praisonaiagents/tools/excel_tools.py,sha256=e2HqcwnyBueOyss0xEKxff3zB4w4sNWCOMXvZfbDYlE,11309
 praisonaiagents/tools/file_tools.py,sha256=N0fjTxxi89UupAvtEUwXjPrBvbppf8bwaNLfnjZ05q4,10824
 praisonaiagents/tools/json_tools.py,sha256=ApUYNuQ1qnbmYNCxSlx6Tth_H1yo8mhWtZ7Rr2WS6C4,16507
-praisonaiagents/tools/mongodb_tools.py,sha256=Y1n0X58nJkRYMb_ZjlXeH2PENbJlN-OLcfo44N647Dc,21073
+praisonaiagents/tools/mongodb_tools.py,sha256=gmRxV4In0aFVFYWNEOLzg9yP-jCuvFp4Lm_6vWjtlnQ,21505
 praisonaiagents/tools/newspaper_tools.py,sha256=NyhojNPeyULBGcAWGOT1X70qVkh3FgZrpH-S7PEmrwI,12667
 praisonaiagents/tools/pandas_tools.py,sha256=yzCeY4jetKrFIRA15Tr5OQ5d94T8DaSpzglx2UiWfPs,11092
 praisonaiagents/tools/python_tools.py,sha256=4dWJddySR0snCEcQudemg5qvbuNrUYxO-jXnzuWixqM,16461
@@ -67,7 +67,7 @@ praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxN
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
 praisonaiagents/tools/train/data/generatecot.py,sha256=H6bNh-E2hqL5MW6kX3hqZ05g9ETKN2-kudSjiuU_SD8,19403
-praisonaiagents-0.0.153.dist-info/METADATA,sha256=XSemYARB8KbWxIROYpBGh21HcmzkANfMVG7aBt2frsc,2146
-praisonaiagents-0.0.153.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-praisonaiagents-0.0.153.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.153.dist-info/RECORD,,
+praisonaiagents-0.0.155.dist-info/METADATA,sha256=mabCM-bwfCTmlaJuAUCxrdNXS0OWg8hUcIf70c60PC4,2146
+praisonaiagents-0.0.155.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.155.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.155.dist-info/RECORD,,