praisonaiagents 0.0.145__py3-none-any.whl → 0.0.146__py3-none-any.whl

praisonaiagents/llm/openai_client.py

@@ -838,14 +838,55 @@ class OpenAIClient:
                 )
             else:
                 # Process as regular non-streaming response
-                final_response = self.create_completion(
-                    messages=messages,
-                    model=model,
-                    temperature=temperature,
-                    tools=formatted_tools,
-                    stream=False,
-                    **kwargs
-                )
+                if display_fn and console:
+                    # When verbose (display_fn provided), use streaming for better UX
+                    try:
+                        with Live(display_fn("", start_time), console=console, refresh_per_second=4, transient=True) as live:
+                            # Use streaming when display_fn is provided for progressive display
+                            response_stream = self.create_completion(
+                                messages=messages,
+                                model=model,
+                                temperature=temperature,
+                                tools=formatted_tools,
+                                stream=True,  # Always stream when verbose/display_fn
+                                **kwargs
+                            )
+                            
+                            full_response_text = ""
+                            chunks = []
+                            
+                            # Process streaming response
+                            for chunk in response_stream:
+                                chunks.append(chunk)
+                                if chunk.choices[0].delta.content:
+                                    full_response_text += chunk.choices[0].delta.content
+                                    live.update(display_fn(full_response_text, start_time))
+                            
+                            # Process final response from chunks
+                            final_response = process_stream_chunks(chunks)
+                        
+                        # Clear the last generating display with a blank line
+                        console.print()
+                    except Exception as e:
+                        self.logger.error(f"Error in Live display for non-streaming: {e}")
+                        # Fallback to regular completion without display
+                        final_response = self.create_completion(
+                            messages=messages,
+                            model=model,
+                            temperature=temperature,
+                            tools=formatted_tools,
+                            stream=False,
+                            **kwargs
+                        )
+                else:
+                    final_response = self.create_completion(
+                        messages=messages,
+                        model=model,
+                        temperature=temperature,
+                        tools=formatted_tools,
+                        stream=False,
+                        **kwargs
+                    )
             
             if not final_response:
                 return None
@@ -969,14 +1010,55 @@ class OpenAIClient:
                 )
             else:
                 # Process as regular non-streaming response
-                final_response = await self.acreate_completion(
-                    messages=messages,
-                    model=model,
-                    temperature=temperature,
-                    tools=formatted_tools,
-                    stream=False,
-                    **kwargs
-                )
+                if display_fn and console:
+                    # When verbose (display_fn provided), use streaming for better UX
+                    try:
+                        with Live(display_fn("", start_time), console=console, refresh_per_second=4, transient=True) as live:
+                            # Use streaming when display_fn is provided for progressive display
+                            response_stream = await self.acreate_completion(
+                                messages=messages,
+                                model=model,
+                                temperature=temperature,
+                                tools=formatted_tools,
+                                stream=True,  # Always stream when verbose/display_fn
+                                **kwargs
+                            )
+                            
+                            full_response_text = ""
+                            chunks = []
+                            
+                            # Process streaming response
+                            async for chunk in response_stream:
+                                chunks.append(chunk)
+                                if chunk.choices[0].delta.content:
+                                    full_response_text += chunk.choices[0].delta.content
+                                    live.update(display_fn(full_response_text, start_time))
+                            
+                            # Process final response from chunks
+                            final_response = process_stream_chunks(chunks)
+                        
+                        # Clear the last generating display with a blank line
+                        console.print()
+                    except Exception as e:
+                        self.logger.error(f"Error in Live display for async non-streaming: {e}")
+                        # Fallback to regular completion without display
+                        final_response = await self.acreate_completion(
+                            messages=messages,
+                            model=model,
+                            temperature=temperature,
+                            tools=formatted_tools,
+                            stream=False,
+                            **kwargs
+                        )
+                else:
+                    final_response = await self.acreate_completion(
+                        messages=messages,
+                        model=model,
+                        temperature=temperature,
+                        tools=formatted_tools,
+                        stream=False,
+                        **kwargs
+                    )
             
             if not final_response:
                 return None

praisonaiagents/memory/memory.py

@@ -138,6 +138,8 @@ class Memory:
         logging.getLogger('httpx').setLevel(logging.WARNING)
         logging.getLogger('httpcore').setLevel(logging.WARNING)
         logging.getLogger('chromadb.segment.impl.vector.local_persistent_hnsw').setLevel(logging.ERROR)
+        logging.getLogger('utils').setLevel(logging.WARNING)
+        logging.getLogger('litellm.utils').setLevel(logging.WARNING)
             
         self.provider = self.cfg.get("provider", "rag")
         self.use_mem0 = (self.provider.lower() == "mem0") and MEM0_AVAILABLE
@@ -1546,3 +1548,46 @@ class Memory:
         logger.info(f"After quality filter: {len(filtered)} results")
         
         return filtered
+
+    def get_all_memories(self) -> List[Dict[str, Any]]:
+        """Get all memories from both short-term and long-term storage"""
+        all_memories = []
+        
+        try:
+            # Get short-term memories
+            conn = sqlite3.connect(self.short_db)
+            c = conn.cursor()
+            rows = c.execute("SELECT id, content, meta, created_at FROM short_mem").fetchall()
+            conn.close()
+            
+            for row in rows:
+                meta = json.loads(row[2] or "{}")
+                all_memories.append({
+                    "id": row[0],
+                    "text": row[1],
+                    "metadata": meta,
+                    "created_at": row[3],
+                    "type": "short_term"
+                })
+            
+            # Get long-term memories
+            conn = sqlite3.connect(self.long_db)
+            c = conn.cursor()
+            rows = c.execute("SELECT id, content, meta, created_at FROM long_mem").fetchall()
+            conn.close()
+            
+            for row in rows:
+                meta = json.loads(row[2] or "{}")
+                all_memories.append({
+                    "id": row[0],
+                    "text": row[1],
+                    "metadata": meta,
+                    "created_at": row[3],
+                    "type": "long_term"
+                })
+            
+            return all_memories
+            
+        except Exception as e:
+            self._log_verbose(f"Error getting all memories: {e}", logging.ERROR)
+            return []

praisonaiagents/telemetry/__init__.py

@@ -1,13 +1,24 @@
 """
-PraisonAI Agents Minimal Telemetry Module
+PraisonAI Agents Telemetry & Performance Monitoring Module
+
+This module provides:
+1. Anonymous usage tracking with privacy-first design  
+2. User-friendly performance monitoring and analysis tools
 
-This module provides anonymous usage tracking with privacy-first design.
 Telemetry is opt-out and can be disabled via environment variables:
 - PRAISONAI_TELEMETRY_DISABLED=true
 - PRAISONAI_DISABLE_TELEMETRY=true  
 - DO_NOT_TRACK=true
 
 No personal data, prompts, or responses are collected.
+
+Performance Monitoring Features:
+- Function performance tracking with detailed statistics
+- API call monitoring and analysis
+- Function execution flow visualization  
+- Performance bottleneck identification
+- Real-time performance reporting
+- CLI interface for easy access
 """
 
 import os
@@ -20,15 +31,64 @@ if TYPE_CHECKING:
 # Import the classes for real (not just type checking)
 from .telemetry import MinimalTelemetry, TelemetryCollector
 
+# Import performance monitoring tools
+try:
+    from .performance_monitor import (
+        PerformanceMonitor, performance_monitor,
+        monitor_function, track_api_call, get_performance_report,
+        get_function_stats, get_api_stats, get_slowest_functions, 
+        get_slowest_apis, clear_performance_data
+    )
+    from .performance_utils import (
+        FunctionFlowAnalyzer, PerformanceAnalyzer,
+        flow_analyzer, performance_analyzer,
+        analyze_function_flow, visualize_execution_flow,
+        analyze_performance_trends, generate_comprehensive_report
+    )
+    from .performance_cli import PerformanceCLI
+    PERFORMANCE_MONITORING_AVAILABLE = True
+except ImportError:
+    PERFORMANCE_MONITORING_AVAILABLE = False
+
 __all__ = [
+    # Core telemetry
     'get_telemetry',
     'enable_telemetry',
-    'disable_telemetry',
+    'disable_telemetry', 
     'force_shutdown_telemetry',
     'MinimalTelemetry',
     'TelemetryCollector',  # For backward compatibility
 ]
 
+# Add performance monitoring to __all__ if available
+if PERFORMANCE_MONITORING_AVAILABLE:
+    __all__.extend([
+        # Performance monitoring classes
+        'PerformanceMonitor',
+        'FunctionFlowAnalyzer', 
+        'PerformanceAnalyzer',
+        'PerformanceCLI',
+        # Global instances
+        'performance_monitor',
+        'flow_analyzer',
+        'performance_analyzer',
+        # Convenience functions
+        'monitor_function',
+        'track_api_call',
+        'get_performance_report',
+        'get_function_stats',
+        'get_api_stats',
+        'get_slowest_functions',
+        'get_slowest_apis',
+        'clear_performance_data',
+        'analyze_function_flow',
+        'visualize_execution_flow',
+        'analyze_performance_trends',
+        'generate_comprehensive_report',
+        # Availability flag
+        'PERFORMANCE_MONITORING_AVAILABLE'
+    ])
+
 
 def get_telemetry() -> 'MinimalTelemetry':
     """Get the global telemetry instance."""

praisonaiagents/telemetry/integration.py

@@ -42,13 +42,27 @@ def instrument_agent(agent: 'Agent', telemetry: Optional['MinimalTelemetry'] = N
     if original_chat:
         @wraps(original_chat)
         def instrumented_chat(*args, **kwargs):
+            import threading
+            
             try:
                 result = original_chat(*args, **kwargs)
-                telemetry.track_agent_execution(agent.name, success=True)
+                # Track success asynchronously to prevent blocking
+                def track_async():
+                    try:
+                        telemetry.track_agent_execution(agent.name, success=True)
+                    except:
+                        pass  # Ignore telemetry errors
+                threading.Thread(target=track_async, daemon=True).start()
                 return result
             except Exception as e:
-                telemetry.track_agent_execution(agent.name, success=False)
-                telemetry.track_error(type(e).__name__)
+                # Track error asynchronously
+                def track_error_async():
+                    try:
+                        telemetry.track_agent_execution(agent.name, success=False)
+                        telemetry.track_error(type(e).__name__)
+                    except:
+                        pass  # Ignore telemetry errors
+                threading.Thread(target=track_error_async, daemon=True).start()
                 raise
         
         agent.chat = instrumented_chat
@@ -57,13 +71,53 @@ def instrument_agent(agent: 'Agent', telemetry: Optional['MinimalTelemetry'] = N
     if original_start:
         @wraps(original_start)
         def instrumented_start(*args, **kwargs):
+            import types
+            import threading
+            
             try:
                 result = original_start(*args, **kwargs)
-                telemetry.track_agent_execution(agent.name, success=True)
-                return result
+                
+                # Check if result is a generator (streaming mode)
+                if isinstance(result, types.GeneratorType):
+                    # For streaming, defer telemetry tracking to avoid blocking
+                    def streaming_wrapper():
+                        try:
+                            for chunk in result:
+                                yield chunk
+                            # Track success only after streaming completes
+                            # Use a separate thread to make it truly non-blocking
+                            def track_async():
+                                try:
+                                    telemetry.track_agent_execution(agent.name, success=True)
+                                except:
+                                    pass  # Ignore telemetry errors
+                            threading.Thread(target=track_async, daemon=True).start()
+                        except Exception as e:
+                            # Track error immediately
+                            threading.Thread(target=lambda: telemetry.track_agent_execution(agent.name, success=False), daemon=True).start()
+                            threading.Thread(target=lambda: telemetry.track_error(type(e).__name__), daemon=True).start()
+                            raise
+                    
+                    return streaming_wrapper()
+                else:
+                    # For non-streaming, track immediately but asynchronously
+                    def track_async():
+                        try:
+                            telemetry.track_agent_execution(agent.name, success=True)
+                        except:
+                            pass  # Ignore telemetry errors
+                    threading.Thread(target=track_async, daemon=True).start()
+                    return result
+                    
             except Exception as e:
-                telemetry.track_agent_execution(agent.name, success=False)
-                telemetry.track_error(type(e).__name__)
+                # Track error immediately but asynchronously
+                def track_error_async():
+                    try:
+                        telemetry.track_agent_execution(agent.name, success=False)
+                        telemetry.track_error(type(e).__name__)
+                    except:
+                        pass  # Ignore telemetry errors
+                threading.Thread(target=track_error_async, daemon=True).start()
                 raise
         
         agent.start = instrumented_start
@@ -72,13 +126,27 @@ def instrument_agent(agent: 'Agent', telemetry: Optional['MinimalTelemetry'] = N
     if original_run:
         @wraps(original_run)
         def instrumented_run(*args, **kwargs):
+            import threading
+            
             try:
                 result = original_run(*args, **kwargs)
-                telemetry.track_agent_execution(agent.name, success=True)
+                # Track success asynchronously to prevent blocking
+                def track_async():
+                    try:
+                        telemetry.track_agent_execution(agent.name, success=True)
+                    except:
+                        pass  # Ignore telemetry errors
+                threading.Thread(target=track_async, daemon=True).start()
                 return result
             except Exception as e:
-                telemetry.track_agent_execution(agent.name, success=False)
-                telemetry.track_error(type(e).__name__)
+                # Track error asynchronously
+                def track_error_async():
+                    try:
+                        telemetry.track_agent_execution(agent.name, success=False)
+                        telemetry.track_error(type(e).__name__)
+                    except:
+                        pass  # Ignore telemetry errors
+                threading.Thread(target=track_error_async, daemon=True).start()
                 raise
         
         agent.run = instrumented_run