Base OpenAI LLM service

src/dailyai/pipeline/aggregators.py

@@ -19,10 +19,22 @@ from dailyai.pipeline.frames import (
 from dailyai.pipeline.pipeline import Pipeline
 from dailyai.services.ai_services import AIService
 
-from typing import AsyncGenerator, Coroutine, List
+from typing import AsyncGenerator, Callable, Coroutine, List
+
+from dailyai.services.openai_llm_context import OpenAILLMContext
 
 class ResponseAggregator(FrameProcessor):
-    def __init__(self, *, messages: list[dict], role: str, start_frame, end_frame, accumulator_frame, pass_through=True):
+
+    def __init__(
+        self,
+        *,
+        messages: list[dict] | None,
+        role: str,
+        start_frame,
+        end_frame,
+        accumulator_frame,
+        pass_through=True,
+    ):
         self.aggregation = ""
         self.aggregating = False
         self.messages = messages
@@ -35,6 +47,9 @@ class ResponseAggregator(FrameProcessor):
     async def process_frame(
         self, frame: Frame
     ) -> AsyncGenerator[Frame, None]:
+        if not self.messages:
+            return
+
         if isinstance(frame, self._start_frame):
             self.aggregating = True
         elif isinstance(frame, self._end_frame):
@@ -70,6 +85,7 @@ class UserResponseAggregator(ResponseAggregator):
             pass_through=False
         )
 
+
 class LLMContextAggregator(AIService):
     def __init__(
         self,

src/dailyai/pipeline/frames.py

@@ -1,5 +1,7 @@
 from dataclasses import dataclass
-from typing import Any
+from typing import Any, List
+
+from dailyai.services.openai_llm_context import OpenAILLMContext
 
 
 class Frame:
@@ -60,7 +62,12 @@ class TranscriptionQueueFrame(TextFrame):
 
 @dataclass()
 class LLMMessagesQueueFrame(Frame):
-    messages: list[dict[str, str]]  # TODO: define this more concretely!
+    messages: List[dict]
+
+
+@dataclass()
+class OpenAILLMContextFrame(Frame):
+    context: OpenAILLMContext
 
 
 class AppMessageQueueFrame(Frame):
@@ -79,4 +86,4 @@ class LLMFunctionStartFrame(Frame):
 @dataclass()
 class LLMFunctionCallFrame(Frame):
     function_name: str
-    arguments: str
+    arguments: str

src/dailyai/pipeline/opeanai_llm_aggregator.py

@@ -0,0 +1,106 @@
+from typing import Any, AsyncGenerator, Callable
+from dailyai.pipeline.frame_processor import FrameProcessor
+from dailyai.pipeline.frames import (
+    Frame,
+    LLMResponseEndFrame,
+    LLMResponseStartFrame,
+    OpenAILLMContextFrame,
+    TextFrame,
+    TranscriptionQueueFrame,
+    UserStartedSpeakingFrame,
+    UserStoppedSpeakingFrame,
+)
+from dailyai.services.openai_llm_context import OpenAILLMContext
+
+from openai.types.chat import ChatCompletionRole
+
+
+class OpenAIContextAggregator(FrameProcessor):
+
+    def __init__(
+        self,
+        context: OpenAILLMContext,
+        aggregator: Callable[[Frame, str | None], str | None],
+        role: ChatCompletionRole,
+        start_frame: type,
+        end_frame: type,
+        accumulator_frame: type,
+        pass_through=True,
+    ):
+        if not (
+            issubclass(start_frame, Frame)
+            and issubclass(end_frame, Frame)
+            and issubclass(accumulator_frame, Frame)
+        ):
+            raise TypeError(
+                "start_frame, end_frame and accumulator_frame must be instances of Frame"
+            )
+
+        self._context: OpenAILLMContext = context
+        self._aggregator: Callable[[Frame, str | None], None] = aggregator
+        self._role: ChatCompletionRole = role
+        self._start_frame = start_frame
+        self._end_frame = end_frame
+        self._accumulator_frame = accumulator_frame
+        self._pass_through = pass_through
+
+        self._aggregating = False
+        self._aggregation = None
+
+    async def process_frame(self, frame: Frame) -> AsyncGenerator[Frame, None]:
+        if isinstance(frame, self._start_frame):
+            self._aggregating = True
+        elif isinstance(frame, self._end_frame):
+            self._aggregating = False
+            if self._aggregation:
+                self._context.add_message(
+                    {
+                        "role": self._role,
+                        "content": self._aggregation,
+                        "name": self._role,
+                    }  # type: ignore
+                )
+            self._aggregation = None
+            yield OpenAILLMContextFrame(self._context)
+        elif isinstance(frame, self._accumulator_frame) and self._aggregating:
+            self._aggregation = self._aggregator(frame, self._aggregation)
+            if self._pass_through:
+                yield frame
+        else:
+            yield frame
+
+    def string_aggregator(self, frame: Frame, aggregation: str | None) -> str | None:
+        if not isinstance(frame, TextFrame):
+            raise TypeError(
+                "Frame must be a TextFrame instance to be aggregated by a string aggregator."
+            )
+        if not aggregation:
+            aggregation = ""
+        return " ".join([aggregation, frame.text])
+
+
+class OpenAIUserContextAggregator(OpenAIContextAggregator):
+    def __init__(self, context: OpenAILLMContext):
+        super().__init__(
+            context=context,
+            aggregator=self.string_aggregator,
+            role="user",
+            start_frame=UserStartedSpeakingFrame,
+            end_frame=UserStoppedSpeakingFrame,
+            accumulator_frame=TranscriptionQueueFrame,
+            pass_through=False,
+        )
+
+
+class OpenAIAssistantContextAggregator(OpenAIContextAggregator):
+
+    def __init__(self, context:OpenAILLMContext):
+        super().__init__(
+            context,
+            aggregator=self.string_aggregator,
+            role="assistant",
+            start_frame=LLMResponseStartFrame,
+            end_frame=LLMResponseEndFrame,
+            accumulator_frame=TextFrame,
+            pass_through=True,
+        )