praisonaiagents 0.0.144__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

@@ -10,9 +10,19 @@ from datetime import datetime
 # Disable litellm telemetry before any imports
 os.environ["LITELLM_TELEMETRY"] = "False"
 
-# Set up logger
+# Set up logger with custom TRACE level
 logger = logging.getLogger(__name__)
 
+# Add custom TRACE level (below DEBUG)
+TRACE_LEVEL = 5
+logging.addLevelName(TRACE_LEVEL, 'TRACE')
+
+def trace(self, message, *args, **kwargs):
+    if self.isEnabledFor(TRACE_LEVEL):
+        self._log(TRACE_LEVEL, message, args, **kwargs)
+
+logging.Logger.trace = trace
+
 try:
     import chromadb
     from chromadb.config import Settings as ChromaSettings
@@ -128,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
@@ -770,7 +782,7 @@ class Memory:
                     import litellm
                     
                     logger.info("Getting embeddings from LiteLLM...")
-                    logger.debug(f"Embedding input text: {text}")
+                    logger.trace(f"Embedding input text: {text}")
                     
                     response = litellm.embedding(
                         model=self.embedding_model,
@@ -778,7 +790,7 @@ class Memory:
                     )
                     embedding = response.data[0]["embedding"]
                     logger.info("Successfully got embeddings from LiteLLM")
-                    logger.debug(f"Received embedding of length: {len(embedding)}")
+                    logger.trace(f"Received embedding of length: {len(embedding)}")
                     
                 elif OPENAI_AVAILABLE:
                     # Fallback to OpenAI client
@@ -786,7 +798,7 @@ class Memory:
                     client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
                     
                     logger.info("Getting embeddings from OpenAI...")
-                    logger.debug(f"Embedding input text: {text}")
+                    logger.trace(f"Embedding input text: {text}")
                     
                     response = client.embeddings.create(
                         input=text,
@@ -794,7 +806,7 @@ class Memory:
                     )
                     embedding = response.data[0].embedding
                     logger.info("Successfully got embeddings from OpenAI")
-                    logger.debug(f"Received embedding of length: {len(embedding)}")
+                    logger.trace(f"Received embedding of length: {len(embedding)}")
                 else:
                     logger.warning("Neither litellm nor openai available for embeddings")
                     return
@@ -1243,12 +1255,22 @@ class Memory:
         task_descr: str,
         user_id: Optional[str] = None,
         additional: str = "",
-        max_items: int = 3
+        max_items: int = 3,
+        include_in_output: Optional[bool] = None
     ) -> str:
         """
         Merges relevant short-term, long-term, entity, user memories
         into a single text block with deduplication and clean formatting.
+        
+        Args:
+            include_in_output: If None, memory content is only included when debug logging is enabled.
+                               If True, memory content is always included.
+                               If False, memory content is never included (only logged for debugging).
         """
+        # Determine whether to include memory content in output based on logging level
+        if include_in_output is None:
+            include_in_output = logging.getLogger().getEffectiveLevel() == logging.DEBUG
+        
         q = (task_descr + " " + additional).strip()
         lines = []
         seen_contents = set()  # Track unique contents
@@ -1306,16 +1328,20 @@ class Memory:
                     formatted_hits.append(formatted)
             
             if formatted_hits:
-                # Add section header
-                if lines:
-                    lines.append("")  # Space before new section
-                lines.append(title)
-                lines.append("=" * len(title))  # Underline the title
-                lines.append("")  # Space after title
+                # Log detailed memory content for debugging including section headers
+                brief_title = title.replace(" Context", "").replace("Memory ", "")
+                logger.debug(f"Memory section '{brief_title}' ({len(formatted_hits)} items): {formatted_hits}")
                 
-                # Add formatted content with bullet points
-                for content in formatted_hits:
-                    lines.append(f" • {content}")
+                # Only include memory content in output when specified (controlled by log level or explicit parameter)
+                if include_in_output:
+                    # Add only the actual memory content for AI agent use (no headers)
+                    if lines:
+                        lines.append("")  # Space before new section
+                    
+                    # Include actual memory content without verbose section headers
+                    for hit in formatted_hits:
+                        lines.append(f"• {hit}")
+                    lines.append("")  # Space after content
 
         # Add each section
         # First get all results
@@ -1522,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/task/task.py

@@ -402,13 +402,14 @@ Expected Output: {self.expected_output}.
                     context_results.append(f"Input Content: {' '.join(str(x) for x in context_item)}")
                 elif hasattr(context_item, 'result'):  # Task object
                     if context_item.result:
-                        context_results.append(
-                            f"Result of previous task {context_item.name if context_item.name else context_item.description}:\n{context_item.result.raw}"
-                        )
+                        task_name = context_item.name if context_item.name else context_item.description
+                        # Log detailed result for debugging
+                        logger.debug(f"Previous task '{task_name}' result: {context_item.result.raw}")
+                        # Include actual result content without verbose labels (essential for task chaining)
+                        context_results.append(context_item.result.raw)
                     else:
-                        context_results.append(
-                            f"Previous task {context_item.name if context_item.name else context_item.description} has no result yet."
-                        )
+                        # Task has no result yet, don't include verbose status message
+                        pass
 
             # Join unique context results
             unique_contexts = list(dict.fromkeys(context_results))  # Remove duplicates

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