Created DiscordMessageAdapter for creating ClientMessage instance instead of a builder's class method

Moved all dataclasses to .openai_client.models.py
Made prompt into its own dataclass
Removed to_dict methods because dataclasses/asdict seems to be sufficient

reginaldCog/llm_clients/llm_client.py

@@ -0,0 +1,210 @@
+from abc import ABC, abstractmethod
+from openai import OpenAI
+from ..messenger_clients.messenger_client import ClientMessage
+
+
+class ILLMContent(ABC):
+    pass
+
+
+class OpenAIContent(ILLMContent):
+    def __init__(self):
+        self._content_items: list[dict[str, str]] = []
+
+    @property
+    def content_items(self) -> list[dict]:
+        return self._content_items
+
+    @content_items.setter
+    def content_items(self, value: list[dict[str, str]]):
+        self._content_items = value
+
+
+class ILLMContentBuilder(ABC):
+    pass
+
+
+class OpenAIContentBuilder(ILLMContentBuilder):
+    def __init__(self, content: OpenAIContent):
+        self.content = content
+
+    def add_output_text(self, text: str):
+        item = {"type": "output_text", "text": text}
+        self.content.content_items.append(item)
+        return self
+
+    def add_input_text(self, text: str):
+        item = {"type": "input_text", "text": text}
+        self.content.content_items.append(item)
+        return self
+
+    def add_input_image(self, image_url: str):
+        item = {"type": "input_image", "image_url": image_url}
+        self.content.content_items.append(item)
+        return self
+
+    def add_from_dict(self, item: dict):
+        self.content.content_items.append(item)
+        return self
+
+
+class ILLMMessage(ABC):
+    pass
+
+
+class OpenAIMessage(ILLMMessage):
+    def __init__(self):
+        self.content = OpenAIContent()
+        self.role = ""
+
+    @property
+    def to_dict(self):
+        return {"role": self.role, "content": self.content.content_items}
+
+
+class ILLMMessageBuilder(ABC):
+    pass
+
+
+class OpenAIMessageBuilder(ILLMMessageBuilder):
+    def __init__(self, message: OpenAIMessage):
+        self.message = message
+
+    def set_role(self, role: str):
+        self.message.role = role
+        return self
+
+    def set_content(self, content: OpenAIContent):
+        self.message.content = content
+        return self
+
+
+class ILLMPrompt(ABC):
+    pass
+
+
+class OpenAIPrompt(ILLMPrompt):
+    def __init__(self):
+        self.messages = []
+
+    @property
+    def to_list(self):
+        return [i_message.to_dict for i_message in self.messages]
+
+
+class ILLMPromptBuilder(ABC):
+    @abstractmethod
+    def __init__(self, prompt: ILLMPrompt):
+        pass
+
+    @abstractmethod
+    def add_message(self, message: ILLMMessage):
+        pass
+
+
+class OpenAIPromptBuilder(ILLMPromptBuilder):
+    def __init__(self, prompt: OpenAIPrompt):
+        self.prompt = prompt
+
+    def add_message(self, message: OpenAIMessage):
+        self.prompt.messages.append(message)
+
+
+class ILLMClient(ABC):
+    @abstractmethod
+    def get_response(self, prompt: ILLMPrompt):
+        pass
+
+
+class OpenAIClient(ILLMClient):
+    def __init__(self):
+        self.model = 'gpt-4.1-mini'
+        self.client = OpenAI()
+
+    def get_response(self, prompt: OpenAIPrompt):
+        response_input = {"model": self.model, "input": prompt.to_list}
+        return self.client.responses.create(**response_input)
+
+
+class IMessageAdapter(ABC):
+    @abstractmethod
+    def to_message(self) -> ILLMMessage:
+        pass
+
+
+class OpenAIResponseAdapter(IMessageAdapter):
+    def __init__(self, response):
+        self.response = response
+        self.response_output = response.output[0]
+
+    def to_message(self) -> OpenAIMessage:
+        content = OpenAIContent()
+        content_builder = OpenAIContentBuilder(content)
+        message = OpenAIMessage()
+        message_builder = OpenAIMessageBuilder(message)
+
+        message_builder.set_role(self.response_output.role)\
+                       .set_content(content)
+
+        for i_content_item in self.response_output.content:
+            item = i_content_item.to_dict()
+            content_builder.add_from_dict(item)
+
+        return message
+
+
+class MessengerMessageAdapter(IMessageAdapter):
+    def __init__(self, message: ClientMessage):  # Dependency Inversion violation, figure out later
+        self.message = message
+
+    def to_message(self) -> ILLMMessage:
+        content = OpenAIContent()
+        content_builder = OpenAIContentBuilder(content)
+        message = OpenAIMessage()
+        message_builder = OpenAIMessageBuilder(message)
+
+        message_builder.set_role("user")\
+                       .set_content(content)
+
+        if self.message:
+            content_builder.add_input_text(self.message.content)
+        for i_image_url in self.message.image_urls:
+            content_builder.add_input_image(i_image_url)
+
+        return message
+
+
+if __name__ == "__main__":
+    dev_message_text = "You are a butler named Reginald. Give your answers in a refined manners of the English butler."
+    user_message_text = "Hi! Tell me about yourself!"
+
+    # Create developer message content and message
+    dev_content = OpenAIContent()
+    dev_content_builder = OpenAIContentBuilder(dev_content).add_input_text(dev_message_text)
+    dev_message = OpenAIMessage()
+    OpenAIMessageBuilder(dev_message).set_role("developer").set_content(dev_content)
+
+    # Create user message content and message
+    user_content = OpenAIContent()
+    OpenAIContentBuilder(user_content).add_input_text(user_message_text)
+    user_message = OpenAIMessage()
+    OpenAIMessageBuilder(user_message).set_role("user").set_content(user_content)
+
+    # Create prompt and add messages
+    test_prompt = OpenAIPrompt()
+    prompt_builder = OpenAIPromptBuilder(test_prompt)
+    prompt_builder.add_message(dev_message)
+    prompt_builder.add_message(user_message)
+
+    # Create client and get response
+    client = OpenAIClient()
+    test_response = client.get_response(test_prompt)
+
+    # Create response adapter and add response to prompt
+    response_adapter = OpenAIResponseAdapter(test_response)
+    response_message = response_adapter.to_message()
+    prompt_builder.add_message(response_message)
+
+    # Print messages
+    print(test_prompt.to_list)
+

reginaldCog/llm_clients/openai_data_models.py

@@ -0,0 +1,71 @@
+from dataclasses import dataclass, field
+from abc import ABC
+
+
+# region Content classes
+@dataclass(frozen=True)
+class Content(ABC):
+    type: str = field(init=False, default='')
+
+
+@dataclass(frozen=True)
+class InputText(Content):
+    type: str = field(init=False, default='input_text')
+    text: str
+
+
+@dataclass(frozen=True)
+class OutputText(Content):
+    type: str = field(init=False, default='output_text')
+    text: str
+
+
+@dataclass(frozen=True)
+class InputImage(Content):
+    type: str = field(init=False, default='input_image')
+    image_url: str | None = field(default=None)
+    file_id: str | None = field(default=None)
+
+    def __post_init__(self):
+        if self.image_url is None and self.file_id is None:
+            raise ValueError('Either `image_url` or `file_id` must be provided.')
+
+
+@dataclass(frozen=True)
+class UrlCitation(Content):
+    type: str = field(init=False, default='url_citation')
+    # To be done
+
+
+@dataclass(frozen=True)
+class FunctionCall(Content):
+    type: str = field(init=False, default='function_call')
+    id: str
+    call_id: str
+    name: str
+    arguments: dict
+
+
+@dataclass(frozen=True)
+class FunctionCallOutput(Content):
+    type: str = field(init=False, default='function_call_output')
+    call_id: str
+    output: str
+# endregion Content classes
+
+
+@dataclass(frozen=True)
+class Message:
+    role: str
+    content: list[Content]
+
+
+@dataclass(frozen=True)
+class Prompt:
+    model: str
+    input: list[Message]
+
+
+@dataclass(frozen=True)
+class Response:
+    output: list[Message]

reginaldCog/messenger_clients/discord_data_models.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+
+
+# region dataclasses
+@dataclass(frozen=True)
+class Attachment:
+    content_type: str
+    filename: str
+    id: int
+    size: int
+    url: str
+    ephemeral: bool = False
+
+
+@dataclass(frozen=True)
+class Channel:
+    created_at: datetime
+    id: int
+    name: str
+
+    def __str__(self) -> str:
+        return self.name
+
+
+@dataclass(frozen=True)
+class Role:
+    id: int
+    name: str
+
+    def __str__(self) -> str:
+        return self.name
+
+
+@dataclass(frozen=True)
+class Member:
+    bot: bool
+    created_at: datetime
+    display_name: str  # For regular users this is just their global name or their username, but if they have a guild specific nickname then that is returned instead.
+    global_name: str  # The user's global nickname, taking precedence over the username in display.
+    id: int
+    joined_at: datetime
+    mention: str
+    name: str  # The user's username.
+    nick: str  # The guild specific nickname of the user. Takes precedence over the global name.
+    roles: list[Role] = field(default_factory=list)
+
+    def __str__(self) -> str:
+        return self.name
+
+
+@dataclass(frozen=True)
+class Message:
+    author: Member
+    channel: Channel
+    created_at: datetime
+    id: int
+    attachments: list[Attachment] = field(default_factory=list)
+    channel_mentions: list[Channel] = field(default_factory=list)
+    content: str = ''
+    mentions: list[Member] = field(default_factory=list)
+
+
+if __name__ == '__main__':
+    pass

reginaldCog/messenger_clients/messenger_client.py

@@ -0,0 +1,77 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+from discord import Message, Attachment
+
+
+class IClientMessage(ABC):
+    @abstractmethod
+    def __init__(self):
+        pass
+
+
+class ClientMessage(IClientMessage):
+    def __init__(self):
+        self.author_name: str = ''
+        self.content: str = ''
+        self.image_urls: list = []
+
+
+class IMessageBuilder(ABC):
+    @abstractmethod
+    def __init__(self):
+        pass
+
+    @abstractmethod
+    def set_content(self, value: str):
+        pass
+
+    @abstractmethod
+    def set_author_name(self, value: str):
+        pass
+
+    @abstractmethod
+    def set_image_urls(self, value: list[str]):
+        pass
+
+
+class DiscordMessageBuilder(IMessageBuilder):
+    def __init__(self, message: IClientMessage):
+        self.message = message
+
+    def set_author_name(self, value: str):
+        self.message.author_name = value
+        return self
+
+    def set_content(self, value: str):
+        self.message.content = value
+        return self
+
+    def set_image_urls(self, value: list[str]):
+        self.message.image_urls = value
+        return self
+
+
+class IMessageAdapter(ABC):
+    @abstractmethod
+    def create_message(self, message: object) -> IClientMessage:
+        pass
+
+    @staticmethod
+    def validate_image_urls(urls_list: list[Attachment]) -> list[str]:
+        supported_image_formats = ('image/jpeg', 'image/png', 'image/webp', 'image/gif')
+        return [i_attachment.url for i_attachment in urls_list if i_attachment.content_type in supported_image_formats]
+
+
+class DiscordMessageAdapter(IMessageAdapter):
+    def create_message(self, message: Message) -> IClientMessage:
+        client_message = ClientMessage()
+        message_builder = DiscordMessageBuilder(client_message)
+        urls_list = self.validate_image_urls(message.attachments)
+        message_builder.set_content(message.content)\
+                       .set_author_name(message.author.name)\
+                       .set_image_urls(urls_list)
+        return client_message
+
+
+if __name__ == "__main__":
+    pass

reginaldCog/reginald.py

@@ -16,7 +16,6 @@ from .weather import time_now, get_current_weather, get_weather_forecast
 from .tools_description import TOOLS
 from .debug_stuff import debug
 
-
 CALLABLE_FUNCTIONS = {
     # Dictionary with functions to call.
     # You can use globals()[func_name](**args) instead, but that's too implicit.
@@ -80,7 +79,6 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
         if not (await self.is_admin(message) or await self.has_access(message.author)):
             return  # Ignore message if user has no permissions
 
-
         guild = message.guild
         channel_id = str(message.channel.id)
         user_id = str(message.author.id)
@@ -116,7 +114,7 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
                     return
                 explicit_invocation = True
 
-        # ✅ Passive Listening: Check if the message contains relevant keywords
+            # ✅ Passive Listening: Check if the message contains relevant keywords
             elif self.should_reginald_interject(message_content):
                 prompt = message_content
                 explicit_invocation = False
@@ -124,11 +122,11 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
             else:
                 return  # Ignore irrelevant messages
 
-        # ✅ Context Handling: Maintain conversation flow
+            # ✅ Context Handling: Maintain conversation flow
             if memory and memory[-1]["user"] == user_name:
                 prompt = f"Continuation of the discussion:\n{prompt}"
 
-        # ✅ Prepare context messages
+            # ✅ Prepare context messages
             formatted_messages = [{"role": "system", "content": self.get_reginald_persona()}]
 
             if user_profile:
@@ -145,10 +143,10 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
                         "content": f"[{summary['timestamp']}] Topics: {', '.join(summary['topics'])}\n{summary['summary']}"
                     })
 
-            formatted_messages += [{"role": "user", "content": f"{entry['user']}: {entry['content']}"} for entry in memory]
+            formatted_messages += [{"role": "user", "content": f"{entry['user']}: {entry['content']}"} for entry in
+                                   memory]
             formatted_messages.append({"role": "user", "content": f"{user_name}: {prompt}"})
 
-
             ##################################################
             #                                                #
             ## Generate AI Response, put into response_text ##
@@ -166,7 +164,8 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
             memory.append({"user": "Reginald", "content": response_text})
 
             if len(memory) > self.short_term_memory_limit:
-                summary = await self.summarize_memory(message, memory[:int(self.short_term_memory_limit * self.summary_retention_ratio)])
+                summary = await self.summarize_memory(message, memory[:int(
+                    self.short_term_memory_limit * self.summary_retention_ratio)])
                 mid_memory.setdefault(channel_id, []).append({
                     "timestamp": datetime.datetime.now().strftime("%Y-%m-%d %H:%M"),
                     "topics": self.extract_topics_from_summary(summary),
@@ -174,18 +173,18 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
                 })
                 if len(mid_memory[channel_id]) > self.summary_retention_limit:
                     mid_memory[channel_id].pop(0)
-                memory = memory[-(self.short_term_memory_limit - int(self.short_term_memory_limit * self.summary_retention_ratio)):]
+                memory = memory[-(self.short_term_memory_limit - int(
+                    self.short_term_memory_limit * self.summary_retention_ratio)):]
 
             short_memory[channel_id] = memory
 
             await self.send_split_message(message.channel, response_text)
 
-
     def should_reginald_interject(self, message_content: str) -> bool:
         """Determines if Reginald should respond to a message based on keywords."""
         direct_invocation = {
-        "reginald,"
+            "reginald,"
-    }
+        }
         message_lower = message_content.lower()
 
         return any(message_lower.startswith(invocation) for invocation in direct_invocation)
@@ -261,7 +260,8 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
         await self.config.guild(ctx.guild).openai_api_key.set(api_key)
         await ctx.send("OpenAI API key set successfully.")
 
-    @commands.command(name="reginald_set_listening_channel", help="Set the channel where Reginald listens for messages.")
+    @commands.command(name="reginald_set_listening_channel",
+                      help="Set the channel where Reginald listens for messages.")
     @commands.has_permissions(administrator=True)
     async def set_listening_channel(self, ctx, channel: discord.TextChannel):
         """Sets the channel where Reginald will listen for passive responses."""
@@ -273,7 +273,8 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
         await self.config.guild(ctx.guild).listening_channel.set(channel.id)
         await ctx.send(f"✅ Reginald will now listen only in {channel.mention}.")
 
-    @commands.command(name="reginald_get_listening_channel", help="Check which channel Reginald is currently listening in.")
+    @commands.command(name="reginald_get_listening_channel",
+                      help="Check which channel Reginald is currently listening in.")
     @commands.has_permissions(administrator=True)
     async def get_listening_channel(self, ctx):
         """Displays the current listening channel."""
@@ -288,17 +289,16 @@ class ReginaldCog(PermissionsMixin, BlacklistMixin, MemoryMixin, commands.Cog):
         else:
             await ctx.send("❌ No listening channel has been set.")
 
-
+    # async def send_long_message(self, ctx, message, prefix: str = ""):
-    async def send_long_message(self, ctx, message, prefix: str = ""):
+    #     """Splits and sends a long message to avoid Discord's 2000-character limit."""
-        """Splits and sends a long message to avoid Discord's 2000-character limit."""
+    #     chunk_size = 1900  # Leave some space for formatting
-        chunk_size = 1900  # Leave some space for formatting
+    #     if prefix:
-        if prefix:
+    #         prefix_length = len(prefix)
-            prefix_length = len(prefix)
+    #         chunk_size -= prefix_length
-            chunk_size -= prefix_length
+    #
-
+    #     for i in range(0, len(message), chunk_size):
-        for i in range(0, len(message), chunk_size):
+    #         chunk = message[i:i + chunk_size]
-            chunk = message[i:i + chunk_size]
+    #         await ctx.send(f"{prefix}{chunk}")
-            await ctx.send(f"{prefix}{chunk}")
 
     async def send_split_message(self, ctx, content: str, prefix: str = ""):
         """