praisonaiagents 0.0.153__tar.gz → 0.0.155__tar.gz

{praisonaiagents-0.0.153 → praisonaiagents-0.0.155}/PKG-INFO

@@ -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 → praisonaiagents-0.0.155}/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-0.0.153 → praisonaiagents-0.0.155}/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-0.0.153 → praisonaiagents-0.0.155}/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-0.0.153 → praisonaiagents-0.0.155}/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-0.0.153 → praisonaiagents-0.0.155}/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-0.0.153 → praisonaiagents-0.0.155}/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 → praisonaiagents-0.0.155}/praisonaiagents.egg-info/PKG-INFO

@@ -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 → praisonaiagents-0.0.155}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "praisonaiagents"
-version = "0.0.153"
+version = "0.0.155"
 description = "Praison AI agents for completing complex tasks with Self Reflection Agents"
 requires-python = ">=3.10"
 authors = [