autobyteus 1.1.5__py3-none-any.whl → 1.1.6__py3-none-any.whl

autobyteus/llm/base_llm.py

@@ -15,15 +15,6 @@ class BaseLLM(ABC):
     DEFAULT_SYSTEM_MESSAGE = "You are a helpful assistant"
 
     def __init__(self, model: LLMModel, llm_config: LLMConfig):
-        """
-        Base class for all LLMs. Provides core messaging functionality
-        and extension support.
-
-        Args:
-            model (LLMModel): An LLMModel enum value.
-            llm_config (LLMConfig): Configuration for the LLM including system message, 
-                                   rate limits, token limits, etc.
-        """
         if not isinstance(model, LLMModel):
             raise TypeError(f"Expected LLMModel, got {type(model)}")
         if not isinstance(llm_config, LLMConfig):
@@ -33,100 +24,65 @@ class BaseLLM(ABC):
         self.config = llm_config
         self._extension_registry = ExtensionRegistry()
 
-        # Register TokenUsageTrackingExtension by default
         self._token_usage_extension: TokenUsageTrackingExtension = self.register_extension(TokenUsageTrackingExtension)
 
         self.messages: List[Message] = []
-        # Use system_message from config, with fallback to default if not provided
         self.system_message = self.config.system_message or self.DEFAULT_SYSTEM_MESSAGE
         self.add_system_message(self.system_message)
 
     @property
     def latest_token_usage(self):
-        """
-        Get the token usage from the last interaction with the LLM.
-        
-        Returns:
-            The token usage information from the last interaction
-        """
         return self._token_usage_extension.latest_token_usage
 
     def register_extension(self, extension_class: Type[LLMExtension]) -> LLMExtension:
-        """
-        Register a new extension.
-        
-        Args:
-            extension_class: The extension class to instantiate and register
-        
-        Returns:
-            LLMExtension: The instantiated extension
-        """
         extension = extension_class(self)
         self._extension_registry.register(extension)
         return extension
 
     def unregister_extension(self, extension: LLMExtension) -> None:
-        """
-        Unregister an existing extension.
-        
-        Args:
-            extension (LLMExtension): The extension to unregister
-        """
         self._extension_registry.unregister(extension)
 
     def get_extension(self, extension_class: Type[LLMExtension]) -> Optional[LLMExtension]:
-        """
-        Get a registered extension by its class.
-        
-        Args:
-            extension_class: The class of the extension to retrieve
-            
-        Returns:
-            Optional[LLMExtension]: The extension instance if found, None otherwise
-        """
         return self._extension_registry.get(extension_class)
 
     def add_system_message(self, message: str):
-        """
-        Add a system message to the conversation history.
+        self.messages.append(Message(MessageRole.SYSTEM, content=message))
 
-        Args:
-            message (str): The system message content.
+    def add_user_message(self, user_message: LLMUserMessage):
         """
-        self.messages.append(Message(MessageRole.SYSTEM, message))
-
-    def add_user_message(self, user_message: Union[str, List[Dict]]):
+        Adds a user message to history, converting from LLMUserMessage to Message.
         """
-        Add a user message to the conversation history.
-
-        Args:
-            user_message (Union[str, List[Dict]]): The user message content. Can be a simple string
-                                                   or a list of dictionaries for multimodal content.
-        """
-        msg = Message(MessageRole.USER, user_message) 
+        msg = Message(
+            role=MessageRole.USER,
+            content=user_message.content,
+            image_urls=user_message.image_urls,
+            audio_urls=user_message.audio_urls,
+            video_urls=user_message.video_urls
+        )
         self.messages.append(msg)
         self._trigger_on_user_message_added(msg)
 
-    def add_assistant_message(self, message: str, reasoning_content: Optional[str] = None):
-        """
-        Add an assistant message to the conversation history.
-
-        Args:
-            message (str): The assistant message content.
-            reasoning_content (Optional[str]): Optional reasoning content to attach.
-        """
-        msg = Message(MessageRole.ASSISTANT, message, reasoning_content=reasoning_content)
+    def add_assistant_message(self,
+                              content: Optional[str],
+                              reasoning_content: Optional[str] = None,
+                              image_urls: Optional[List[str]] = None,
+                              audio_urls: Optional[List[str]] = None,
+                              video_urls: Optional[List[str]] = None):
+        """
+        Adds a multimodal assistant message to the conversation history.
+        """
+        msg = Message(
+            role=MessageRole.ASSISTANT,
+            content=content,
+            reasoning_content=reasoning_content,
+            image_urls=image_urls,
+            audio_urls=audio_urls,
+            video_urls=video_urls
+        )
         self.messages.append(msg)
         self._trigger_on_assistant_message_added(msg)
 
     def configure_system_prompt(self, new_system_prompt: str):
-        """
-        Updates the system prompt for the LLM instance after initialization.
-        This will replace the existing system message in the conversation history.
-
-        Args:
-            new_system_prompt (str): The new system prompt content.
-        """
         if not new_system_prompt or not isinstance(new_system_prompt, str):
             logging.warning("Attempted to configure an empty or invalid system prompt. No changes made.")
             return
@@ -134,7 +90,6 @@ class BaseLLM(ABC):
         self.system_message = new_system_prompt
         self.config.system_message = new_system_prompt
 
-        # Find and update the existing system message, or add a new one if not found.
         system_message_found = False
         for i, msg in enumerate(self.messages):
             if msg.role == MessageRole.SYSTEM:
@@ -144,113 +99,65 @@ class BaseLLM(ABC):
                 break
         
         if not system_message_found:
-            # If for some reason no system message was there, insert it at the beginning.
             self.messages.insert(0, Message(MessageRole.SYSTEM, new_system_prompt))
             logging.debug("No existing system message found, inserted new one at the beginning.")
         
         logging.info(f"LLM instance system prompt updated. New prompt length: {len(new_system_prompt)}")
 
     def _trigger_on_user_message_added(self, message: Message):
-        """
-        Internal helper to invoke the on_user_message_added hook on every extension.
-
-        Args:
-            message (Message): The user message that was added
-        """
         for extension in self._extension_registry.get_all():
             extension.on_user_message_added(message)
 
     def _trigger_on_assistant_message_added(self, message: Message):
-        """
-        Internal helper to invoke the on_assistant_message_added hook on every extension.
-
-        Args:
-            message (Message): The assistant message that was added
-        """
         for extension in self._extension_registry.get_all():
             extension.on_assistant_message_added(message)
 
     async def _execute_before_hooks(self, user_message: LLMUserMessage, **kwargs) -> None:
-        """
-        Execute all registered before_invoke hooks.
-        """
         for extension in self._extension_registry.get_all():
-            await extension.before_invoke(user_message.content, user_message.image_urls, **kwargs)
+            await extension.before_invoke(user_message, **kwargs)
 
     async def _execute_after_hooks(self, user_message: LLMUserMessage, response: CompleteResponse = None, **kwargs) -> None:
-        """
-        Execute all registered after_invoke hooks.
-        
-        Args:
-            user_message (LLMUserMessage): The user message object
-            response (CompleteResponse): The complete response from the LLM
-            **kwargs: Additional arguments for LLM-specific usage
-        """
         for extension in self._extension_registry.get_all():
-            await extension.after_invoke(user_message.content, user_message.image_urls, response, **kwargs)
+            await extension.after_invoke(user_message, response, **kwargs)
 
     async def send_user_message(self, user_message: LLMUserMessage, **kwargs) -> CompleteResponse:
-        """
-        Sends a user message to the LLM and returns the complete LLM response.
-
-        Args:
-            user_message (LLMUserMessage): The user message object.
-            **kwargs: Additional arguments for LLM-specific usage.
-
-        Returns:
-            CompleteResponse: The complete response from the LLM including content and usage.
-        """
         await self._execute_before_hooks(user_message, **kwargs)
-        response = await self._send_user_message_to_llm(
-            user_message.content, 
-            user_message.image_urls if user_message.image_urls else None, 
-            **kwargs
-        )
+        response = await self._send_user_message_to_llm(user_message, **kwargs)
         await self._execute_after_hooks(user_message, response, **kwargs)
         return response
 
     async def stream_user_message(self, user_message: LLMUserMessage, **kwargs) -> AsyncGenerator[ChunkResponse, None]:
-        """
-        Streams the LLM response as ChunkResponse objects.
-
-        Args:
-            user_message (LLMUserMessage): The user message object.
-            **kwargs: Additional arguments for LLM-specific usage.
-
-        Yields:
-            AsyncGenerator[ChunkResponse, None]: ChunkResponse objects from the LLM.
-        """
         await self._execute_before_hooks(user_message, **kwargs)
 
         accumulated_content = ""
+        accumulated_reasoning = ""
         final_chunk = None
         
-        async for chunk in self._stream_user_message_to_llm(
-            user_message.content, 
-            user_message.image_urls if user_message.image_urls else None, 
-            **kwargs
-        ):
-            accumulated_content += chunk.content
+        async for chunk in self._stream_user_message_to_llm(user_message, **kwargs):
+            if chunk.content:
+                accumulated_content += chunk.content
+            if chunk.reasoning:
+                accumulated_reasoning += chunk.reasoning
+
             if chunk.is_complete:
                 final_chunk = chunk
             yield chunk
 
-        # Create a CompleteResponse from the accumulated content and final chunk's usage
         complete_response = CompleteResponse(
             content=accumulated_content,
+            reasoning=accumulated_reasoning if accumulated_reasoning else None,
             usage=final_chunk.usage if final_chunk else None
         )
         
         await self._execute_after_hooks(user_message, complete_response, **kwargs)
 
     @abstractmethod
-    async def _send_user_message_to_llm(self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs) -> CompleteResponse:
+    async def _send_user_message_to_llm(self, user_message: LLMUserMessage, **kwargs) -> CompleteResponse:
         """
         Abstract method for sending a user message to an LLM. Must be implemented by subclasses.
         
         Args:
-            user_message (str): The user message content.
-            image_urls (Optional[List[str]]): Optional list of image URLs or file paths.
+            user_message (LLMUserMessage): The user message object.
             **kwargs: Additional arguments for LLM-specific usage.
             
         Returns:
@@ -259,13 +166,12 @@ class BaseLLM(ABC):
         pass
 
     @abstractmethod
-    async def _stream_user_message_to_llm(self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs) -> AsyncGenerator[ChunkResponse, None]:
+    async def _stream_user_message_to_llm(self, user_message: LLMUserMessage, **kwargs) -> AsyncGenerator[ChunkResponse, None]:
         """
         Abstract method for streaming a user message response from the LLM. Must be implemented by subclasses.
         
         Args:
-            user_message (str): The user message content.
-            image_urls (Optional[List[str]]): Optional list of image URLs or file paths.
+            user_message (LLMUserMessage): The user message object.
             **kwargs: Additional arguments for LLM-specific usage.
             
         Yields:
@@ -274,9 +180,6 @@ class BaseLLM(ABC):
         pass
 
     async def cleanup(self):
-        """
-        Perform cleanup operations for the LLM and all extensions.
-        """
         for extension in self._extension_registry.get_all():
             await extension.cleanup()
         self._extension_registry.clear()

autobyteus/llm/extensions/base_extension.py

@@ -2,6 +2,7 @@ from abc import ABC, abstractmethod
 from typing import List, Optional, TYPE_CHECKING
 from autobyteus.llm.utils.messages import Message
 from autobyteus.llm.utils.response_types import CompleteResponse
+from autobyteus.llm.user_message import LLMUserMessage
 
 if TYPE_CHECKING:
     from autobyteus.llm.base_llm import BaseLLM
@@ -12,7 +13,7 @@ class LLMExtension(ABC):
 
     @abstractmethod
     async def before_invoke(
-        self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs
+        self, user_message: LLMUserMessage, **kwargs
     ) -> None:
         """
         Called before invoking the LLM with a user message.
@@ -21,16 +22,15 @@ class LLMExtension(ABC):
 
     @abstractmethod
     async def after_invoke(
-        self, user_message: str, image_urls: Optional[List[str]] = None, response: CompleteResponse = None, **kwargs
+        self, user_message: LLMUserMessage, response: CompleteResponse = None, **kwargs
     ) -> None:
         """
         Called after receiving the response from the LLM.
         
         Args:
-            user_message: Original user message
-            image_urls: Optional image URLs used in request
-            response: Complete response including content and usage information
-            kwargs: Additional arguments
+            user_message: The original user message object.
+            response: Complete response including content and usage information.
+            kwargs: Additional arguments.
         """
         pass
 

autobyteus/llm/extensions/token_usage_tracking_extension.py

@@ -6,6 +6,7 @@ from autobyteus.llm.utils.token_usage import TokenUsage
 from autobyteus.llm.utils.token_usage_tracker import TokenUsageTracker
 from autobyteus.llm.utils.messages import Message, MessageRole
 from autobyteus.llm.utils.response_types import CompleteResponse
+from autobyteus.llm.user_message import LLMUserMessage
 
 if TYPE_CHECKING:
     from autobyteus.llm.base_llm import BaseLLM
@@ -29,12 +30,12 @@ class TokenUsageTrackingExtension(LLMExtension):
         return self._latest_usage
 
     async def before_invoke(
-        self, user_message: str, image_urls: Optional[List[str]] = None, **kwargs
+        self, user_message: LLMUserMessage, **kwargs
     ) -> None:
         pass
 
     async def after_invoke(
-        self, user_message: str, image_urls: Optional[List[str]] = None, response: CompleteResponse = None, **kwargs
+        self, user_message: LLMUserMessage, response: CompleteResponse = None, **kwargs
     ) -> None:
         """
         Get the latest usage from tracker and optionally override token counts with provider's usage if available

autobyteus/llm/llm_factory.py

@@ -10,6 +10,7 @@ from autobyteus.llm.utils.llm_config import LLMConfig, TokenPricingConfig
 from autobyteus.llm.base_llm import BaseLLM
 
 from autobyteus.llm.api.claude_llm import ClaudeLLM
+from autobyteus.llm.api.bedrock_llm import BedrockLLM
 from autobyteus.llm.api.mistral_llm import MistralLLM
 from autobyteus.llm.api.openai_llm import OpenAILLM
 from autobyteus.llm.api.deepseek_llm import DeepSeekLLM
@@ -61,6 +62,83 @@ class LLMFactory(metaclass=SingletonMeta):
                     pricing_config=TokenPricingConfig(2.50, 10.00)
                 )
             ),
+            LLMModel(
+                name="gpt-5",
+                value="gpt-5",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-5",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(1.25, 10.00)
+                )
+            ),
+            LLMModel(
+                name="gpt-5-mini",
+                value="gpt-5-mini",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-5-mini",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(0.25, 2.00)
+                )
+            ),
+            LLMModel(
+                name="gpt-5-nano",
+                value="gpt-5-nano",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-5-nano",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(0.05, 0.40)
+                )
+            ),
+            LLMModel(
+                name="gpt-5-chat-latest",
+                value="gpt-5-chat-latest",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-5-chat-latest",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(1.25, 10.00)
+                )
+            ),
+            LLMModel(
+                name="gpt-4.1",
+                value="gpt-4.1",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-4.1",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(2.00, 8.00)
+                )
+            ),
+            LLMModel(
+                name="gpt-4.1-mini",
+                value="gpt-4.1-mini",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-4.1-mini",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(0.40, 1.60)
+                )
+            ),
+            LLMModel(
+                name="gpt-4.1-nano",
+                value="gpt-4.1-nano",
+                provider=LLMProvider.OPENAI,
+                llm_class=OpenAILLM,
+                canonical_name="gpt-4.1-nano",
+                default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
+                    pricing_config=TokenPricingConfig(0.10, 0.40)
+                )
+            ),
             LLMModel(
                 name="o3",
                 value="o3",
@@ -68,6 +146,7 @@ class LLMFactory(metaclass=SingletonMeta):
                 llm_class=OpenAILLM,
                 canonical_name="o3",
                 default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
                     pricing_config=TokenPricingConfig(15.00, 60.00)
                 )
             ),
@@ -78,6 +157,7 @@ class LLMFactory(metaclass=SingletonMeta):
                 llm_class=OpenAILLM,
                 canonical_name="o4-mini",
                 default_config=LLMConfig(
+                    uses_max_completion_tokens=True,
                     pricing_config=TokenPricingConfig(1.0, 4.00)
                 )
             ),
@@ -104,12 +184,13 @@ class LLMFactory(metaclass=SingletonMeta):
                 )
             ),
             LLMModel(
-                name="bedrock-claude-4-opus",
-                value="anthropic.claude-opus-4-20250514-v1:0",
+                name="claude-4.1-opus",
+                value="claude-opus-4-1-20250805",
                 provider=LLMProvider.ANTHROPIC,
                 llm_class=ClaudeLLM,
-                canonical_name="claude-4-opus",
+                canonical_name="claude-4.1-opus",
                 default_config=LLMConfig(
+                    # NOTE: Pricing is assumed to be the same as claude-4-opus
                     pricing_config=TokenPricingConfig(15.00, 75.00)
                 )
             ),
@@ -123,11 +204,32 @@ class LLMFactory(metaclass=SingletonMeta):
                     pricing_config=TokenPricingConfig(3.00, 15.00)
                 )
             ),
+            LLMModel(
+                name="bedrock-claude-4-opus",
+                value="anthropic.claude-opus-4-20250514-v1:0",
+                provider=LLMProvider.ANTHROPIC,
+                llm_class=BedrockLLM,
+                canonical_name="claude-4-opus",
+                default_config=LLMConfig(
+                    pricing_config=TokenPricingConfig(15.00, 75.00)
+                )
+            ),
+            LLMModel(
+                name="bedrock-claude-4.1-opus",
+                value="anthropic.claude-opus-4-1-20250805-v1:0",
+                provider=LLMProvider.ANTHROPIC,
+                llm_class=BedrockLLM,
+                canonical_name="claude-4.1-opus",
+                default_config=LLMConfig(
+                    # NOTE: Pricing is assumed to be the same as claude-4-opus
+                    pricing_config=TokenPricingConfig(15.00, 75.00)
+                )
+            ),
             LLMModel(
                 name="bedrock-claude-4-sonnet",
                 value="anthropic.claude-sonnet-4-20250514-v1:0",
                 provider=LLMProvider.ANTHROPIC,
-                llm_class=ClaudeLLM,
+                llm_class=BedrockLLM,
                 canonical_name="claude-4-sonnet",
                 default_config=LLMConfig(
                     pricing_config=TokenPricingConfig(3.00, 15.00)

autobyteus/llm/token_counter/token_counter_factory.py

@@ -25,7 +25,7 @@ def get_token_counter(model: LLMModel, llm: 'BaseLLM') -> BaseTokenCounter:
     if model.provider == LLMProvider.OPENAI:
         return OpenAITokenCounter(model, llm)
     elif model.provider == LLMProvider.ANTHROPIC:
-        return ClaudeTokenCounter(model, llm)
+        return OpenAITokenCounter(model, llm)
     elif model.provider == LLMProvider.MISTRAL:
         return MistralTokenCounter(model, llm)
     elif model.provider == LLMProvider.DEEPSEEK:

autobyteus/llm/user_message.py

@@ -7,53 +7,65 @@ logger = logging.getLogger(__name__)
 class LLMUserMessage:
     """
     Represents a user message formatted specifically for input to an LLM.
-    It includes content and optionally image URLs.
-    This structure is typically used when constructing prompts for multimodal LLMs
-    or when sending a "user" role message in a conversation.
+    It includes content and optionally URLs for various media types.
+    This structure is typically used when constructing prompts for multimodal LLMs.
     """
     def __init__(self,
                  content: str,
-                 image_urls: Optional[List[str]] = None):
+                 image_urls: Optional[List[str]] = None,
+                 audio_urls: Optional[List[str]] = None,
+                 video_urls: Optional[List[str]] = None):
         """
         Initializes an LLMUserMessage.
 
         Args:
             content: The textual content of the user's message.
-            image_urls: An optional list of URLs or local paths to images
-                        to be included with the message for the LLM.
+            image_urls: An optional list of URLs or local paths to images.
+            audio_urls: An optional list of URLs or local paths to audio files.
+            video_urls: An optional list of URLs or local paths to video files.
         """
-        if not isinstance(content, str):
-            # Allow empty string for content, as images might be the only input.
-            # But content must still be a string type.
-            pass # Validation can be more strict if empty content is disallowed with no images
-        
-        if image_urls is None:
-            image_urls = [] # Default to empty list for easier processing
+        self.content: str = content
+        self.image_urls: List[str] = image_urls or []
+        self.audio_urls: List[str] = audio_urls or []
+        self.video_urls: List[str] = video_urls or []
 
-        if not (isinstance(image_urls, list) and all(isinstance(url, str) for url in image_urls)):
+        # --- Validation ---
+        if not isinstance(self.content, str):
+            raise TypeError("LLMUserMessage 'content' must be a string.")
+        if not (isinstance(self.image_urls, list) and all(isinstance(url, str) for url in self.image_urls)):
             raise TypeError("LLMUserMessage 'image_urls' must be a list of strings.")
-        
-        if not content and not image_urls:
-            raise ValueError("LLMUserMessage must have either content or image_urls or both.")
+        if not (isinstance(self.audio_urls, list) and all(isinstance(url, str) for url in self.audio_urls)):
+            raise TypeError("LLMUserMessage 'audio_urls' must be a list of strings.")
+        if not (isinstance(self.video_urls, list) and all(isinstance(url, str) for url in self.video_urls)):
+            raise TypeError("LLMUserMessage 'video_urls' must be a list of strings.")
 
-        self.content: str = content
-        self.image_urls: List[str] = image_urls
+        if not self.content and not self.image_urls and not self.audio_urls and not self.video_urls:
+            raise ValueError("LLMUserMessage must have either content or at least one media URL.")
 
-        logger.debug(f"LLMUserMessage created. Content: '{content[:50]}...', Image URLs: {image_urls}")
+        logger.debug(f"LLMUserMessage created. Content: '{self.content[:50]}...', "
+                     f"Images: {len(self.image_urls)}, Audio: {len(self.audio_urls)}, Video: {len(self.video_urls)}")
 
     def __repr__(self) -> str:
-        image_urls_repr = f", image_urls={self.image_urls}" if self.image_urls else ""
-        return f"LLMUserMessage(content='{self.content[:100]}...'{image_urls_repr})"
+        parts = [f"content='{self.content[:100]}...'"]
+        if self.image_urls:
+            parts.append(f"image_urls={self.image_urls}")
+        if self.audio_urls:
+            parts.append(f"audio_urls={self.audio_urls}")
+        if self.video_urls:
+            parts.append(f"video_urls={self.video_urls}")
+        return f"LLMUserMessage({', '.join(parts)})"
 
     def to_dict(self) -> Dict[str, Any]:
         """
-        Serializes the LLMUserMessage to a dictionary. This method might be less used
-        now that BaseLLM._add_user_message handles the conversion to the Message format.
-        Kept for potential direct use or testing.
+        Serializes the LLMUserMessage to a dictionary.
         """
         data = {"content": self.content}
         if self.image_urls:
             data["image_urls"] = self.image_urls
+        if self.audio_urls:
+            data["audio_urls"] = self.audio_urls
+        if self.video_urls:
+            data["video_urls"] = self.video_urls
         return data
 
     @classmethod
@@ -61,13 +73,9 @@ class LLMUserMessage:
         """
         Deserializes an LLMUserMessage from a dictionary.
         """
-        content = data.get("content", "") # Default to empty string if not present
-        image_urls = data.get("image_urls") # Expects a list or None
-
-        # Basic validation, more can be added if needed
-        if not isinstance(content, str):
-             raise ValueError("LLMUserMessage 'content' in dictionary must be a string.")
-        if image_urls is not None and not (isinstance(image_urls, list) and all(isinstance(url, str) for url in image_urls)):
-            raise ValueError("LLMUserMessage 'image_urls' in dictionary must be a list of strings if provided.")
-
-        return cls(content=content, image_urls=image_urls)
+        return cls(
+            content=data.get("content", ""),
+            image_urls=data.get("image_urls"),
+            audio_urls=data.get("audio_urls"),
+            video_urls=data.get("video_urls")
+        )