PipelineTask: add add_observer() and remove_observer()

src/pipecat/pipeline/task.py

@@ -225,14 +225,16 @@ class PipelineTask(BaseTask):
                 )
             observers = self._params.observers
         observers = observers or []
+        self._turn_tracking_observer: Optional[TurnTrackingObserver] = None
+        self._turn_trace_observer: Optional[TurnTraceObserver] = None
         if self._enable_turn_tracking:
             self._turn_tracking_observer = TurnTrackingObserver()
-            observers = [self._turn_tracking_observer] + list(observers)
-        if self._enable_turn_tracking and self._enable_tracing:
+            observers.append(self._turn_tracking_observer)
+        if self._enable_tracing and self._turn_tracking_observer:
             self._turn_trace_observer = TurnTraceObserver(
                 self._turn_tracking_observer, conversation_id=self._conversation_id
             )
-            observers = [self._turn_trace_observer] + list(observers)
+            observers.append(self._turn_trace_observer)
         self._finished = False
 
         # This queue receives frames coming from the pipeline upstream.
@@ -297,12 +299,18 @@ class PipelineTask(BaseTask):
     @property
     def turn_tracking_observer(self) -> Optional[TurnTrackingObserver]:
         """Return the turn tracking observer if enabled."""
-        return getattr(self, "_turn_tracking_observer", None)
+        return self._turn_tracking_observer
 
     @property
     def turn_trace_observer(self) -> Optional[TurnTraceObserver]:
         """Return the turn trace observer if enabled."""
-        return getattr(self, "_turn_trace_observer", None)
+        return self._turn_trace_observer
+
+    async def add_observer(self, observer: BaseObserver):
+        await self._observer.add_observer(observer)
+
+    async def remove_observer(self, observer: BaseObserver):
+        await self._observer.remove_observer(observer)
 
     def set_event_loop(self, loop: asyncio.AbstractEventLoop):
         self._task_manager.set_event_loop(loop)

src/pipecat/pipeline/task_observer.py

@@ -6,7 +6,7 @@
 
 import asyncio
 import inspect
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 from attr import dataclass
 
@@ -44,7 +44,22 @@ class TaskObserver(BaseObserver):
     ):
         self._observers = observers or []
         self._task_manager = task_manager
-        self._proxies: List[Proxy] = []
+        self._proxies: Dict[BaseObserver, Proxy] = {}
+
+    async def add_observer(self, observer: BaseObserver):
+        proxy = self._create_proxy(observer)
+        self._proxies[observer] = proxy
+        self._observers.append(observer)
+
+    async def remove_observer(self, observer: BaseObserver):
+        if observer in self._proxies:
+            proxy = self._proxies[observer]
+            # Remove the proxy so it doesn't get called anymore.
+            del self._proxies[observer]
+            # Cancel the proxy task right away.
+            await self._task_manager.cancel_task(proxy.task)
+            # Remove the observer.
+            self._observers.remove(observer)
 
     async def start(self):
         """Starts all proxy observer tasks."""
@@ -52,23 +67,27 @@ class TaskObserver(BaseObserver):
 
     async def stop(self):
         """Stops all proxy observer tasks."""
-        for proxy in self._proxies:
+        for proxy in self._proxies.values():
             await self._task_manager.cancel_task(proxy.task)
 
     async def on_push_frame(self, data: FramePushed):
-        for proxy in self._proxies:
+        for proxy in self._proxies.values():
             await proxy.queue.put(data)
 
-    def _create_proxies(self, observers) -> List[Proxy]:
-        proxies = []
+    def _create_proxy(self, observer: BaseObserver) -> Proxy:
+        queue = asyncio.Queue()
+        task = self._task_manager.create_task(
+            self._proxy_task_handler(queue, observer),
+            f"TaskObserver::{observer.__class__.__name__}::_proxy_task_handler",
+        )
+        proxy = Proxy(queue=queue, task=task, observer=observer)
+        return proxy
+
+    def _create_proxies(self, observers: List[BaseObserver]) -> Dict[BaseObserver, Proxy]:
+        proxies = {}
         for observer in observers:
-            queue = asyncio.Queue()
-            task = self._task_manager.create_task(
-                self._proxy_task_handler(queue, observer),
-                f"TaskObserver::{observer.__class__.__name__}::_proxy_task_handler",
-            )
-            proxy = Proxy(queue=queue, task=task, observer=observer)
-            proxies.append(proxy)
+            proxy = self._create_proxy(observer)
+            proxies[observer] = proxy
         return proxies
 
     async def _proxy_task_handler(self, queue: asyncio.Queue, observer: BaseObserver):