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

praisonaiagents/agent/agent.py

@@ -383,6 +383,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 +391,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 +408,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 +426,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
                 

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-0.0.153.dist-info → praisonaiagents-0.0.154.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: praisonaiagents
-Version: 0.0.153
+Version: 0.0.154
 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.154.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=pecp8Bt7_vXCB4MfUuMTZ3no4WipKOzFPGhFF5ADC5Y,144243
 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
@@ -21,13 +21,13 @@ praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9b
 praisonaiagents/knowledge/chunking.py,sha256=G6wyHa7_8V0_7VpnrrUXbEmUmptlT16ISJYaxmkSgmU,7678
 praisonaiagents/knowledge/knowledge.py,sha256=OzK81oA6sjk9nAUWphS7AkXxvalrv2AHB4FtHjzYgxI,30115
 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
@@ -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.154.dist-info/METADATA,sha256=55cpHdKamPJ_tSTDYyXli-REfXLqafPKW7GH-Gf_Sdo,2146
+praisonaiagents-0.0.154.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+praisonaiagents-0.0.154.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.154.dist-info/RECORD,,