fix: eliminate streaming pause caused by synchronous telemetry tracking

- Add async_mode parameter to track_agent_execution() to enable background PostHog capture
- Update telemetry integration to auto-detect streaming agents and use async mode
- Maintains backward compatibility for non-streaming agents
- Resolves pause issue after "execution tracked: success=True" message in streaming workflows

Fixes #1031

Co-authored-by: Mervin Praison <MervinPraison@users.noreply.github.com>

Author: github-actions[bot]

src/praisonai-agents/praisonaiagents/telemetry/integration.py

@@ -44,10 +44,13 @@ def instrument_agent(agent: 'Agent', telemetry: Optional['MinimalTelemetry'] = N
         def instrumented_chat(*args, **kwargs):
             try:
                 result = original_chat(*args, **kwargs)
-                telemetry.track_agent_execution(agent.name, success=True)
+                # Detect if agent is in streaming mode to prevent blocking
+                is_streaming = getattr(agent, 'stream', False)
+                telemetry.track_agent_execution(agent.name, success=True, async_mode=is_streaming)
                 return result
             except Exception as e:
-                telemetry.track_agent_execution(agent.name, success=False)
+                # Always use async mode for error tracking to avoid further delays
+                telemetry.track_agent_execution(agent.name, success=False, async_mode=True)
                 telemetry.track_error(type(e).__name__)
                 raise
 
@@ -59,10 +62,13 @@ def instrumented_chat(*args, **kwargs):
         def instrumented_start(*args, **kwargs):
             try:
                 result = original_start(*args, **kwargs)
-                telemetry.track_agent_execution(agent.name, success=True)
+                # Detect if agent is in streaming mode to prevent blocking
+                is_streaming = getattr(agent, 'stream', False)
+                telemetry.track_agent_execution(agent.name, success=True, async_mode=is_streaming)
                 return result
             except Exception as e:
-                telemetry.track_agent_execution(agent.name, success=False)
+                # Always use async mode for error tracking to avoid further delays
+                telemetry.track_agent_execution(agent.name, success=False, async_mode=True)
                 telemetry.track_error(type(e).__name__)
                 raise
 
@@ -74,10 +80,13 @@ def instrumented_start(*args, **kwargs):
         def instrumented_run(*args, **kwargs):
             try:
                 result = original_run(*args, **kwargs)
-                telemetry.track_agent_execution(agent.name, success=True)
+                # Detect if agent is in streaming mode to prevent blocking
+                is_streaming = getattr(agent, 'stream', False)
+                telemetry.track_agent_execution(agent.name, success=True, async_mode=is_streaming)
                 return result
             except Exception as e:
-                telemetry.track_agent_execution(agent.name, success=False)
+                # Always use async mode for error tracking to avoid further delays
+                telemetry.track_agent_execution(agent.name, success=False, async_mode=True)
                 telemetry.track_error(type(e).__name__)
                 raise
 

src/praisonai-agents/praisonaiagents/telemetry/telemetry.py

@@ -119,32 +119,56 @@ def _get_framework_version(self) -> str:
         except (ImportError, KeyError, AttributeError):
             return "unknown"
 
-    def track_agent_execution(self, agent_name: str = None, success: bool = True):
+    def track_agent_execution(self, agent_name: str = None, success: bool = True, async_mode: bool = False):
         """
         Track an agent execution event.
         
         Args:
             agent_name: Name of the agent (not logged, just for counting)
             success: Whether the execution was successful
+            async_mode: If True, defer PostHog capture to prevent blocking in streaming scenarios
         """
         if not self.enabled:
             return
 
         with self._metrics_lock:
             self._metrics["agent_executions"] += 1
 
+        # Always log immediately for debugging
+        self.logger.debug(f"Agent execution tracked: success={success}")
+        
         # Send event to PostHog
         if self._posthog:
-            self._posthog.capture(
-                distinct_id=self.session_id,
-                event='agent_execution',
-                properties={
-                    'success': success,
-                    'session_id': self.session_id
-                }
-            )
-        
-        self.logger.debug(f"Agent execution tracked: success={success}")
+            if async_mode:
+                # Use a background thread to prevent blocking streaming responses
+                def _async_capture():
+                    try:
+                        self._posthog.capture(
+                            distinct_id=self.session_id,
+                            event='agent_execution',
+                            properties={
+                                'success': success,
+                                'session_id': self.session_id
+                            }
+                        )
+                    except Exception as e:
+                        # Silently handle any telemetry errors to avoid disrupting user experience
+                        self.logger.debug(f"Async PostHog capture error: {e}")
+                
+                # Execute in background thread with daemon flag for clean shutdown
+                import threading
+                thread = threading.Thread(target=_async_capture, daemon=True)
+                thread.start()
+            else:
+                # Synchronous capture for backward compatibility
+                self._posthog.capture(
+                    distinct_id=self.session_id,
+                    event='agent_execution',
+                    properties={
+                        'success': success,
+                        'session_id': self.session_id
+                    }
+                )
 
     def track_task_completion(self, task_name: str = None, success: bool = True):
         """