Remove run_to_queue and run from AIService class

src/dailyai/services/ai_services.py

@@ -8,6 +8,7 @@ from dailyai.pipeline.frame_processor import FrameProcessor
 from dailyai.pipeline.frames import (
     AudioFrame,
     EndFrame,
+    EndPipeFrame,
     ImageFrame,
     LLMMessagesQueueFrame,
     LLMResponseEndFrame,
@@ -20,53 +21,13 @@ from dailyai.pipeline.frames import (
 )
 
 from abc import abstractmethod
-from typing import AsyncGenerator, AsyncIterable, BinaryIO, Iterable, List
+from typing import AsyncGenerator, BinaryIO
 
 
 class AIService(FrameProcessor):
-
     def __init__(self):
         self.logger = logging.getLogger("dailyai")
 
-    def stop(self):
-        pass
-
-    async def run_to_queue(
-        self, queue: asyncio.Queue, frames, add_end_of_stream=False
-    ) -> None:
-        async for frame in self.run(frames):
-            await queue.put(frame)
-
-        if add_end_of_stream:
-            await queue.put(EndFrame())
-
-    async def run(
-        self,
-        frames: Iterable[Frame] | AsyncIterable[Frame] | asyncio.Queue[Frame],
-    ) -> AsyncGenerator[Frame, None]:
-        try:
-            if isinstance(frames, AsyncIterable):
-                async for frame in frames:
-                    async for output_frame in self.process_frame(frame):
-                        yield output_frame
-            elif isinstance(frames, Iterable):
-                for frame in frames:
-                    async for output_frame in self.process_frame(frame):
-                        yield output_frame
-            elif isinstance(frames, asyncio.Queue):
-                while True:
-                    frame = await frames.get()
-                    async for output_frame in self.process_frame(frame):
-                        yield output_frame
-                    if isinstance(frame, EndFrame):
-                        break
-            else:
-                raise Exception("Frames must be an iterable or async iterable")
-        except Exception as e:
-            self.logger.error("Exception occurred while running AI service", e)
-            raise e
-
-
 class LLMService(AIService):
     """This class is a no-op but serves as a base class for LLM services."""
 
@@ -92,7 +53,7 @@ class TTSService(AIService):
         yield bytes()
 
     async def process_frame(self, frame: Frame) -> AsyncGenerator[Frame, None]:
-        if isinstance(frame, EndFrame):
+        if isinstance(frame, EndFrame) or isinstance(frame, EndPipeFrame):
             if self.current_sentence:
                 async for audio_chunk in self.run_tts(self.current_sentence):
                     yield AudioFrame(audio_chunk)
@@ -118,12 +79,6 @@ class TTSService(AIService):
             # note we pass along the text frame *after* the audio, so the text frame is completed after the audio is processed.
             yield TextFrame(text)
 
-    # Convenience function to send the audio for a sentence to the given queue
-    async def say(self, sentence, queue: asyncio.Queue):
-        await self.run_to_queue(
-            queue, [LLMResponseStartFrame(), TextFrame(sentence), LLMResponseEndFrame()]
-        )
-
 
 class ImageGenService(AIService):
     def __init__(self, image_size, **kwargs):

src/dailyai/services/base_transport_service.py

@@ -20,11 +20,12 @@ from dailyai.pipeline.frames import (
     PipelineStartedFrame,
     SpriteFrame,
     StartFrame,
-    TranscriptionQueueFrame,
+    TextFrame,
     UserStartedSpeakingFrame,
     UserStoppedSpeakingFrame,
 )
 from dailyai.pipeline.pipeline import Pipeline
+from dailyai.services.ai_services import TTSService
 
 torch.set_num_threads(1)
 
@@ -125,7 +126,7 @@ class BaseTransportService:
 
         self._logger: logging.Logger = logging.getLogger()
 
-    async def run(self):
+    async def run(self, pipeline:Pipeline | None=None, override_pipeline_source_queue=True):
         self._prerun()
 
         async_output_queue_marshal_task = asyncio.create_task(self._marshal_frames())
@@ -148,6 +149,13 @@ class BaseTransportService:
             self._vad_thread = threading.Thread(target=self._vad, daemon=True)
             self._vad_thread.start()
 
+        pipeline_task = None
+        if pipeline:
+            pipeline.set_sink(self.send_queue)
+            if override_pipeline_source_queue:
+                pipeline.set_source(self.receive_queue)
+            pipeline_task =  asyncio.create_task(pipeline.run_pipeline())
+
         try:
             while time.time() < self._expiration and not self._stop_threads.is_set():
                 await asyncio.sleep(1)
@@ -160,9 +168,12 @@ class BaseTransportService:
 
         self._stop_threads.set()
 
+        if pipeline_task:
+            pipeline_task.cancel()
+
         await self.send_queue.put(EndFrame())
+
         await async_output_queue_marshal_task
-        await self.send_queue.join()
         self._frame_consumer_thread.join()
 
         if self._speaker_enabled:
@@ -171,11 +182,6 @@ class BaseTransportService:
         if self._vad_enabled:
             self._vad_thread.join()
 
-    async def run_uninterruptible_pipeline(self, pipeline: Pipeline):
-        pipeline.set_sink(self.send_queue)
-        pipeline.set_source(self.receive_queue)
-        await pipeline.run_pipeline()
-
     async def run_interruptible_pipeline(
         self,
         pipeline: Pipeline,
@@ -232,6 +238,11 @@ class BaseTransportService:
 
         await asyncio.gather(pipeline_task, post_process_task)
 
+    async def say(self, text:str, tts:TTSService):
+        """Say a phrase. Use with caution; this bypasses any running pipelines."""
+        async for frame in tts.process_frame(TextFrame(text)):
+            await self.send_queue.put(frame)
+
     def _post_run(self):
         # Note that this function must be idempotent! It can be called multiple times
         # if, for example, a keyboard interrupt occurs.
@@ -399,6 +410,7 @@ class BaseTransportService:
                 for frame in frames:
                     if isinstance(frame, EndFrame):
                         self._logger.info("Stopping frame consumer thread")
+                        self._stop_threads.set()
                         self._threadsafe_send_queue.task_done()
                         if self._loop:
                             asyncio.run_coroutine_threadsafe(

src/dailyai/services/daily_transport_service.py

@@ -219,7 +219,8 @@ class DailyTransportService(BaseTransportService, EventHandler):
         pass
 
     def call_joined(self, join_data, client_error):
-        self._logger.info(f"Call_joined: {join_data}, {client_error}")
+        #self._logger.info(f"Call_joined: {join_data}, {client_error}")
+        pass
 
     def dialout(self, number):
         self.client.start_dialout({"phoneNumber": number})