autobyteus 1.1.4__tar.gz → 1.1.6__tar.gz

{autobyteus-1.1.4 → autobyteus-1.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.1.4
+Version: 1.1.6
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -15,27 +15,27 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
-Requires-Dist: anthropic==0.37.1
-Requires-Dist: autobyteus-llm-client==1.1.1
-Requires-Dist: beautifulsoup4>=4.12.2
+Requires-Dist: anthropic
+Requires-Dist: autobyteus-llm-client==1.1.3
+Requires-Dist: beautifulsoup4
 Requires-Dist: boto3
 Requires-Dist: botocore
-Requires-Dist: brui-core==1.0.8
+Requires-Dist: brui-core==1.0.9
 Requires-Dist: certifi==2025.4.26
 Requires-Dist: google-api-python-client
 Requires-Dist: google-generativeai
 Requires-Dist: Jinja2
-Requires-Dist: mcp[cli]==1.9.1
-Requires-Dist: mistral_common==1.6.3
+Requires-Dist: mcp[cli]
+Requires-Dist: mistral_common
 Requires-Dist: mistralai
-Requires-Dist: mistralai==1.5.2
-Requires-Dist: numpy==2.2.5
+Requires-Dist: numpy
 Requires-Dist: ollama
 Requires-Dist: openai
 Requires-Dist: requests
 Requires-Dist: rich
 Requires-Dist: textual
-Requires-Dist: tiktoken==0.7.0
+Requires-Dist: tiktoken
+Requires-Dist: tokenizers
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: flake8; extra == "dev"

{autobyteus-1.1.4 → autobyteus-1.1.6}/autobyteus/agent/context/__init__.py

@@ -4,10 +4,12 @@ Components related to the agent's runtime context, state, config, and status man
 """
 from .agent_config import AgentConfig
 from .agent_runtime_state import AgentRuntimeState
-from .agent_context import AgentContext 
+from .agent_context import AgentContext
+from .agent_context_registry import AgentContextRegistry
 
 __all__ = [
     "AgentContext",
     "AgentConfig", 
-    "AgentRuntimeState", 
+    "AgentRuntimeState",
+    "AgentContextRegistry",
 ]

{autobyteus-1.1.4 → autobyteus-1.1.6}/autobyteus/agent/context/agent_config.py

@@ -37,7 +37,7 @@ class AgentConfig:
                  system_prompt: Optional[str] = None,
                  tools: Optional[List['BaseTool']] = None,
                  auto_execute_tools: bool = True,
-                 use_xml_tool_format: bool = True,
+                 use_xml_tool_format: bool = False,
                  input_processors: Optional[List['BaseAgentUserInputMessageProcessor']] = None,
                  llm_response_processors: Optional[List['BaseLLMResponseProcessor']] = None,
                  system_prompt_processors: Optional[List['BaseSystemPromptProcessor']] = None,
@@ -58,7 +58,8 @@ class AgentConfig:
                            llm_instance's config will be used as the base.
             tools: An optional list of pre-initialized tool instances (subclasses of BaseTool).
             auto_execute_tools: If True, the agent will execute tools without approval.
-            use_xml_tool_format: Whether to use XML for tool descriptions and examples.
+            use_xml_tool_format: If True, forces the agent to use XML format for tool
+                                 definitions and parsing, overriding provider defaults.
             input_processors: A list of input processor instances.
             llm_response_processors: A list of LLM response processor instances.
             system_prompt_processors: A list of system prompt processor instances.
@@ -84,7 +85,7 @@ class AgentConfig:
         self.phase_hooks = phase_hooks or []
         self.initial_custom_data = initial_custom_data
 
-        logger.debug(f"AgentConfig created for name '{self.name}', role '{self.role}'.")
+        logger.debug(f"AgentConfig created for name '{self.name}', role '{self.role}'. XML tool format override: {self.use_xml_tool_format}")
 
     def copy(self) -> 'AgentConfig':
         """

autobyteus-1.1.6/autobyteus/agent/context/agent_context_registry.py

@@ -0,0 +1,73 @@
+# file: autobyteus/autobyteus/agent/context/agent_context_registry.py
+import logging
+from typing import Dict, Optional, TYPE_CHECKING
+import weakref
+
+from autobyteus.utils.singleton import SingletonMeta
+
+if TYPE_CHECKING:
+    from .agent_context import AgentContext
+
+logger = logging.getLogger(__name__)
+
+class AgentContextRegistry(metaclass=SingletonMeta):
+    """
+    A singleton registry that holds weak references to active AgentContext objects,
+    keyed by their agent_id.
+
+    This allows other services to look up an agent's context without creating
+    tight coupling or preventing garbage collection.
+    """
+    def __init__(self):
+        self._contexts: Dict[str, weakref.ReferenceType['AgentContext']] = {}
+        logger.info("AgentContextRegistry (Singleton) initialized.")
+
+    def register_context(self, context: 'AgentContext'):
+        """
+        Registers an agent's context. A weak reference is stored to prevent
+        circular references and allow for proper garbage collection.
+
+        Args:
+            context: The AgentContext instance to register.
+        """
+        agent_id = context.agent_id
+        if agent_id in self._contexts and self._contexts[agent_id]() is not None:
+            logger.warning(f"AgentContext for agent_id '{agent_id}' is already registered. Overwriting.")
+        
+        self._contexts[agent_id] = weakref.ref(context)
+        logger.info(f"Registered AgentContext for agent_id '{agent_id}'. Total registered contexts: {len(self._contexts)}")
+
+    def unregister_context(self, agent_id: str):
+        """
+        Unregisters an agent's context, typically on agent shutdown.
+
+        Args:
+            agent_id: The ID of the agent whose context should be removed.
+        """
+        if agent_id in self._contexts:
+            del self._contexts[agent_id]
+            logger.info(f"Unregistered AgentContext for agent_id '{agent_id}'.")
+        else:
+            logger.warning(f"Attempted to unregister a non-existent AgentContext for agent_id '{agent_id}'.")
+
+    def get_context(self, agent_id: str) -> Optional['AgentContext']:
+        """
+        Retrieves an active agent's context by its ID.
+
+        Args:
+            agent_id: The ID of the agent.
+
+        Returns:
+            The AgentContext instance if found and still alive, otherwise None.
+        """
+        context_ref = self._contexts.get(agent_id)
+        if context_ref:
+            context = context_ref()
+            if context:
+                return context
+            else:
+                # The weak reference is dead, so we can clean it up.
+                logger.debug(f"Cleaning up dead weak reference for agent_id '{agent_id}'.")
+                del self._contexts[agent_id]
+        
+        return None

{autobyteus-1.1.4 → autobyteus-1.1.6}/autobyteus/agent/events/notifiers.py

@@ -112,6 +112,10 @@ class AgentExternalEventNotifier(EventEmitter):
     def notify_agent_tool_invocation_auto_executing(self, auto_exec_data: Dict[str, Any]):
         """Notifies that a tool is being automatically executed."""
         self._emit_event(EventType.AGENT_TOOL_INVOCATION_AUTO_EXECUTING, payload_content=auto_exec_data)
+        
+    def notify_agent_data_system_task_notification_received(self, notification_data: Dict[str, Any]):
+        """Notifies that the agent has received a system-generated task notification."""
+        self._emit_event(EventType.AGENT_DATA_SYSTEM_TASK_NOTIFICATION_RECEIVED, payload_content=notification_data)
 
     def notify_agent_error_output_generation(self, error_source: str, error_message: str, error_details: Optional[str] = None): 
         payload_dict = { 

{autobyteus-1.1.4 → autobyteus-1.1.6}/autobyteus/agent/handlers/inter_agent_message_event_handler.py

@@ -6,9 +6,11 @@ from autobyteus.agent.handlers.base_event_handler import AgentEventHandler
 from autobyteus.agent.events import InterAgentMessageReceivedEvent, LLMUserMessageReadyEvent 
 from autobyteus.agent.message.inter_agent_message import InterAgentMessage
 from autobyteus.llm.user_message import LLMUserMessage
+from autobyteus.agent.sender_type import TASK_NOTIFIER_SENDER_ID # New import
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext 
+    from autobyteus.agent.events.notifiers import AgentExternalEventNotifier
 
 logger = logging.getLogger(__name__)
 
@@ -46,6 +48,10 @@ class InterAgentMessageReceivedEventHandler(AgentEventHandler):
             f"Content: '{inter_agent_msg.content}'"
         )
 
+        # This handler now only deals with messages from other agents, not the system notifier.
+        # The logic for system task notifications has been moved to UserInputMessageEventHandler
+        # by checking the message metadata.
+        
         content_for_llm = (
             f"You have received a message from another agent.\n"
             f"Sender Agent ID: {inter_agent_msg.sender_agent_id}\n"
@@ -54,7 +60,7 @@ class InterAgentMessageReceivedEventHandler(AgentEventHandler):
             f"--- Message Content ---\n"
             f"{inter_agent_msg.content}\n"
             f"--- End of Message Content ---\n"
-            f"Please process this information and respond or act accordingly."
+            f"Please process this information and act accordingly."
         )
         
         context.state.add_message_to_history({
@@ -67,7 +73,6 @@ class InterAgentMessageReceivedEventHandler(AgentEventHandler):
         llm_user_message = LLMUserMessage(content=content_for_llm)
         
         llm_user_message_ready_event = LLMUserMessageReadyEvent(llm_user_message=llm_user_message) 
-        # MODIFIED: Use context.input_event_queues and not context.state.queues
         await context.input_event_queues.enqueue_internal_system_event(llm_user_message_ready_event)
         
         logger.info(

{autobyteus-1.1.4 → autobyteus-1.1.6}/autobyteus/agent/handlers/llm_complete_response_received_event_handler.py

@@ -86,10 +86,8 @@ class LLMCompleteResponseReceivedEventHandler(AgentEventHandler):
                             any_processor_took_action = True
                             logger.info(
                                 f"Agent '{agent_id}': LLMResponseProcessor '{processor_name_for_log}' "
-                                f"handled the response. This LLM response "
-                                f"will not be emitted as a complete response by this handler instance."
+                                f"handled the response."
                             )
-                            break 
                         else:
                             logger.debug(f"Agent '{agent_id}': LLMResponseProcessor '{processor_name_for_log}' did not handle the response.")
 
@@ -102,8 +100,7 @@ class LLMCompleteResponseReceivedEventHandler(AgentEventHandler):
                                 error_message="The model's response contained a malformed tool call that could not be understood.",
                                 error_details=str(e_parse)
                             )
-                        any_processor_took_action = True # Mark as handled to prevent printing raw response
-                        break
+                        # A parsing failure should not prevent other processors from running.
 
                     except Exception as e: # pragma: no cover
                         logger.error(f"Agent '{agent_id}': Error while using LLMResponseProcessor '{processor_name_for_log}': {e}. This processor is skipped.", exc_info=True)
@@ -118,21 +115,24 @@ class LLMCompleteResponseReceivedEventHandler(AgentEventHandler):
                 f"Skipping LLMResponseProcessor attempts."
             )
 
-        if not any_processor_took_action:
-            if is_error_response:
-                logger.info(
-                    f"Agent '{agent_id}' emitting a received error message as a complete response: '{complete_response_text[:100]}...'"
+        # Always notify that the LLM's response is complete, regardless of processor actions.
+        # This serves as a critical signal to the frontend that the stream for this turn has ended.
+        if notifier:
+            if any_processor_took_action:
+                log_message = (
+                    f"Agent '{agent_id}': One or more LLMResponseProcessors handled the response. "
+                    f"Now emitting AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE as a completion signal."
                 )
             else:
-                logger.info(
+                log_message = (
                     f"Agent '{agent_id}': No LLMResponseProcessor handled the response. "
-                    f"Emitting the current LLM response as a complete response for this leg."
+                    f"Emitting the full LLM response as a final answer and completion signal."
                 )
-            
-            if notifier:
-                try:
-                    # The complete_response object now contains both content and reasoning
-                    notifier.notify_agent_data_assistant_complete_response(complete_response) 
-                    logger.debug(f"Agent '{agent_id}' emitted AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE event.")
-                except Exception as e_notify: # pragma: no cover
-                    logger.error(f"Agent '{agent_id}': Error emitting AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE: {e_notify}", exc_info=True)
+            logger.info(log_message)
+
+            try:
+                # The complete_response object now contains both content and reasoning
+                notifier.notify_agent_data_assistant_complete_response(complete_response) 
+                logger.debug(f"Agent '{agent_id}' emitted AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE event successfully.")
+            except Exception as e_notify: # pragma: no cover
+                logger.error(f"Agent '{agent_id}': Error emitting AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE: {e_notify}", exc_info=True)

{autobyteus-1.1.4 → autobyteus-1.1.6}/autobyteus/agent/handlers/llm_user_message_ready_event_handler.py

@@ -1,7 +1,7 @@
 # file: autobyteus/autobyteus/agent/handlers/llm_user_message_ready_event_handler.py
 import logging
 import traceback
-from typing import TYPE_CHECKING, cast, Optional
+from typing import TYPE_CHECKING, cast, Optional, List
 
 from autobyteus.agent.handlers.base_event_handler import AgentEventHandler
 from autobyteus.agent.events import LLMUserMessageReadyEvent, LLMCompleteResponseReceivedEvent 
@@ -53,6 +53,9 @@ class LLMUserMessageReadyEventHandler(AgentEventHandler):
         complete_response_text = ""
         complete_reasoning_text = ""
         token_usage: Optional[TokenUsage] = None
+        complete_image_urls: List[str] = []
+        complete_audio_urls: List[str] = []
+        complete_video_urls: List[str] = []
         
         notifier: Optional['AgentExternalEventNotifier'] = None
         if context.phase_manager:
@@ -72,9 +75,19 @@ class LLMUserMessageReadyEventHandler(AgentEventHandler):
                 if chunk_response.reasoning:
                     complete_reasoning_text += chunk_response.reasoning
 
-                if chunk_response.is_complete and chunk_response.usage:
-                    token_usage = chunk_response.usage
-                    logger.debug(f"Agent '{agent_id}' received final chunk with token usage: {token_usage}")
+                if chunk_response.is_complete:
+                    if chunk_response.usage:
+                        token_usage = chunk_response.usage
+                        logger.debug(f"Agent '{agent_id}' received final chunk with token usage: {token_usage}")
+                    if chunk_response.image_urls:
+                        complete_image_urls.extend(chunk_response.image_urls)
+                        logger.debug(f"Agent '{agent_id}' received final chunk with {len(chunk_response.image_urls)} image URLs.")
+                    if chunk_response.audio_urls:
+                        complete_audio_urls.extend(chunk_response.audio_urls)
+                        logger.debug(f"Agent '{agent_id}' received final chunk with {len(chunk_response.audio_urls)} audio URLs.")
+                    if chunk_response.video_urls:
+                        complete_video_urls.extend(chunk_response.video_urls)
+                        logger.debug(f"Agent '{agent_id}' received final chunk with {len(chunk_response.video_urls)} video URLs.")
 
                 if notifier:
                     try:
@@ -121,20 +134,30 @@ class LLMUserMessageReadyEventHandler(AgentEventHandler):
             logger.info(f"Agent '{agent_id}' enqueued LLMCompleteResponseReceivedEvent with error details from LLMUserMessageReadyEventHandler.")
             return 
 
-        # Add message to history with reasoning
+        # Add message to history with reasoning and multimodal data
         history_entry = {"role": "assistant", "content": complete_response_text}
         if complete_reasoning_text:
             history_entry["reasoning"] = complete_reasoning_text
+        if complete_image_urls:
+            history_entry["image_urls"] = complete_image_urls
+        if complete_audio_urls:
+            history_entry["audio_urls"] = complete_audio_urls
+        if complete_video_urls:
+            history_entry["video_urls"] = complete_video_urls
         context.state.add_message_to_history(history_entry)
         
-        # Create complete response with reasoning
+        # Create complete response with reasoning and multimodal data
         complete_response_obj = CompleteResponse(
             content=complete_response_text,
             reasoning=complete_reasoning_text,
-            usage=token_usage
+            usage=token_usage,
+            image_urls=complete_image_urls,
+            audio_urls=complete_audio_urls,
+            video_urls=complete_video_urls
         )
         llm_complete_event = LLMCompleteResponseReceivedEvent(
             complete_response=complete_response_obj
         )
         await context.input_event_queues.enqueue_internal_system_event(llm_complete_event)
         logger.info(f"Agent '{agent_id}' enqueued LLMCompleteResponseReceivedEvent from LLMUserMessageReadyEventHandler.")
+

{autobyteus-1.1.4 → autobyteus-1.1.6}/autobyteus/agent/handlers/user_input_message_event_handler.py

@@ -3,22 +3,23 @@ import logging
 from typing import TYPE_CHECKING
 
 from autobyteus.agent.handlers.base_event_handler import AgentEventHandler
-from autobyteus.agent.events import UserMessageReceivedEvent, LLMUserMessageReadyEvent 
-from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage 
+from autobyteus.agent.events import UserMessageReceivedEvent, LLMUserMessageReadyEvent
+from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
 from autobyteus.agent.input_processor import BaseAgentUserInputMessageProcessor
-from autobyteus.llm.user_message import LLMUserMessage
+from autobyteus.agent.message.multimodal_message_builder import build_llm_user_message
 
 
 if TYPE_CHECKING:
-    from autobyteus.agent.context import AgentContext 
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent.events.notifiers import AgentExternalEventNotifier
 
 logger = logging.getLogger(__name__)
 
 class UserInputMessageEventHandler(AgentEventHandler):
     """
     Handles UserMessageReceivedEvents by first applying any configured
-    AgentUserInputMessageProcessors (provided as instances) to the AgentInputUserMessage,
-    then converting the processed message into an LLMUserMessage, and finally
+    AgentUserInputMessageProcessors, then using the multimodal_message_builder
+    to convert the processed message into an LLMUserMessage, and finally
     enqueuing an LLMUserMessageReadyEvent for further processing by the LLM.
     """
 
@@ -26,17 +27,30 @@ class UserInputMessageEventHandler(AgentEventHandler):
         logger.info("UserInputMessageEventHandler initialized.")
 
     async def handle(self,
-                     event: UserMessageReceivedEvent, 
+                     event: UserMessageReceivedEvent,
                      context: 'AgentContext') -> None:
-        if not isinstance(event, UserMessageReceivedEvent): 
+        if not isinstance(event, UserMessageReceivedEvent):
             logger.warning(f"UserInputMessageEventHandler received non-UserMessageReceivedEvent: {type(event)}. Skipping.")
             return
 
-        original_agent_input_user_msg: AgentInputUserMessage = event.agent_input_user_message 
-        processed_agent_input_user_msg: AgentInputUserMessage = original_agent_input_user_msg 
-        
-        logger.info(f"Agent '{context.agent_id}' handling UserMessageReceivedEvent: '{original_agent_input_user_msg.content}'") 
-        
+        original_agent_input_user_msg: AgentInputUserMessage = event.agent_input_user_message
+
+        # --- NEW LOGIC: Check metadata for system-generated tasks and notify TUI ---
+        if original_agent_input_user_msg.metadata.get('source') == 'system_task_notifier':
+            if context.phase_manager:
+                notifier: 'AgentExternalEventNotifier' = context.phase_manager.notifier
+                notification_data = {
+                    "sender_id": "system.task_notifier",
+                    "content": original_agent_input_user_msg.content,
+                }
+                notifier.notify_agent_data_system_task_notification_received(notification_data)
+                logger.info(f"Agent '{context.agent_id}' emitted system task notification for TUI.")
+        # --- END NEW LOGIC ---
+
+        processed_agent_input_user_msg: AgentInputUserMessage = original_agent_input_user_msg
+
+        logger.info(f"Agent '{context.agent_id}' handling UserMessageReceivedEvent: '{original_agent_input_user_msg.content}'")
+
         processor_instances = context.config.input_processors
         if processor_instances:
             processor_names = [p.get_name() for p in processor_instances]
@@ -47,14 +61,14 @@ class UserInputMessageEventHandler(AgentEventHandler):
                     if not isinstance(processor_instance, BaseAgentUserInputMessageProcessor):
                         logger.error(f"Agent '{context.agent_id}': Invalid input processor type in config: {type(processor_instance)}. Skipping.")
                         continue
-                    
+
                     processor_name_for_log = processor_instance.get_name()
                     logger.debug(f"Agent '{context.agent_id}': Applying input processor '{processor_name_for_log}'.")
                     msg_before_this_processor = processed_agent_input_user_msg
                     # Pass the original event to the processor
                     processed_agent_input_user_msg = await processor_instance.process(
-                        message=msg_before_this_processor, 
-                        context=context, 
+                        message=msg_before_this_processor,
+                        context=context,
                         triggering_event=event
                     )
                     logger.info(f"Agent '{context.agent_id}': Input processor '{processor_name_for_log}' applied successfully.")
@@ -66,12 +80,10 @@ class UserInputMessageEventHandler(AgentEventHandler):
         else:
             logger.debug(f"Agent '{context.agent_id}': No input processors configured in agent config.")
 
-        llm_user_message = LLMUserMessage( 
-            content=processed_agent_input_user_msg.content,
-            image_urls=processed_agent_input_user_msg.image_urls 
-        )
+        # --- Refactored: Use the dedicated builder ---
+        llm_user_message = build_llm_user_message(processed_agent_input_user_msg)
         
-        llm_user_message_ready_event = LLMUserMessageReadyEvent(llm_user_message=llm_user_message) 
+        llm_user_message_ready_event = LLMUserMessageReadyEvent(llm_user_message=llm_user_message)
         await context.input_event_queues.enqueue_internal_system_event(llm_user_message_ready_event)
-        
+
         logger.info(f"Agent '{context.agent_id}' processed AgentInputUserMessage and enqueued LLMUserMessageReadyEvent.")

{autobyteus-1.1.4 → autobyteus-1.1.6}/autobyteus/agent/message/__init__.py

@@ -9,12 +9,14 @@ from .agent_input_user_message import AgentInputUserMessage
 from .send_message_to import SendMessageTo
 from .context_file import ContextFile
 from .context_file_type import ContextFileType
+from .multimodal_message_builder import build_llm_user_message
 
 __all__ = [
-    "InterAgentMessage", 
-    "InterAgentMessageType", 
-    "AgentInputUserMessage", 
+    "InterAgentMessage",
+    "InterAgentMessageType",
+    "AgentInputUserMessage",
     "SendMessageTo",
-    "ContextFile",        
-    "ContextFileType",    
+    "ContextFile",
+    "ContextFileType",
+    "build_llm_user_message",
 ]

{autobyteus-1.1.4 → autobyteus-1.1.6}/autobyteus/agent/message/agent_input_user_message.py

@@ -8,21 +8,18 @@ from .context_file import ContextFile # Import the new ContextFile dataclass
 logger = logging.getLogger(__name__)
 
 @dataclass
-class AgentInputUserMessage: 
+class AgentInputUserMessage:
     """
     Represents a message received from an external user interacting with the agent system.
-    This is a simple dataclass. It includes support for a list of ContextFile objects, 
-    allowing users to provide various documents as context.
+    This is a simple dataclass. It includes support for a list of ContextFile objects,
+    allowing users to provide various documents and media as context via a single list.
     """
     content: str
-    image_urls: Optional[List[str]] = field(default=None) # Basic list of strings
     context_files: Optional[List[ContextFile]] = field(default=None)
     metadata: Dict[str, Any] = field(default_factory=dict)
 
     def __post_init__(self):
         # Basic type validation that dataclasses don't do automatically for mutable defaults or complex types
-        if self.image_urls is not None and not (isinstance(self.image_urls, list) and all(isinstance(url, str) for url in self.image_urls)):
-            raise TypeError("AgentInputUserMessage 'image_urls' must be a list of strings if provided.")
         if self.context_files is not None and not (isinstance(self.context_files, list) and all(isinstance(cf, ContextFile) for cf in self.context_files)):
             raise TypeError("AgentInputUserMessage 'context_files' must be a list of ContextFile objects if provided.")
         if not isinstance(self.metadata, dict): # Should be caught by default_factory, but good practice
@@ -34,7 +31,7 @@ class AgentInputUserMessage:
             num_context_files = len(self.context_files) if self.context_files else 0
             logger.debug(
                 f"AgentInputUserMessage initialized. Content: '{self.content[:50]}...', "
-                f"Image URLs: {self.image_urls}, Num ContextFiles: {num_context_files}, "
+                f"Num ContextFiles: {num_context_files}, "
                 f"Metadata keys: {list(self.metadata.keys())}"
             )
 
@@ -47,7 +44,6 @@ class AgentInputUserMessage:
 
         return {
             "content": self.content,
-            "image_urls": self.image_urls,
             "context_files": context_files_dict_list,
             "metadata": self.metadata,
         }
@@ -59,31 +55,25 @@ class AgentInputUserMessage:
         if not isinstance(content, str): # Ensure content is string
             raise ValueError("AgentInputUserMessage 'content' in dictionary must be a string.")
 
-        image_urls = data.get("image_urls")
-        if image_urls is not None and not (isinstance(image_urls, list) and all(isinstance(url, str) for url in image_urls)):
-            raise ValueError("AgentInputUserMessage 'image_urls' in dictionary must be a list of strings if provided.")
-
         context_files_data = data.get("context_files")
         context_files_list: Optional[List[ContextFile]] = None
         if context_files_data is not None:
             if not isinstance(context_files_data, list):
                 raise ValueError("AgentInputUserMessage 'context_files' in dictionary must be a list if provided.")
             context_files_list = [ContextFile.from_dict(cf_data) for cf_data in context_files_data]
-        
+
         metadata = data.get("metadata", {})
         if not isinstance(metadata, dict):
             raise ValueError("AgentInputUserMessage 'metadata' in dictionary must be a dict if provided.")
 
         return cls(
             content=content,
-            image_urls=image_urls,
             context_files=context_files_list,
             metadata=metadata
         )
 
     def __repr__(self) -> str:
         content_preview = f"{self.content[:100]}..." if len(self.content) > 100 else self.content
-        images_repr = f", image_urls={self.image_urls}" if self.image_urls else ""
         
         if self.context_files:
             context_repr = f", context_files=[{len(self.context_files)} ContextFile(s)]"
@@ -93,4 +83,4 @@ class AgentInputUserMessage:
         meta_repr = f", metadata_keys={list(self.metadata.keys())}" if self.metadata else ""
         
         return (f"AgentInputUserMessage(content='{content_preview}'"
-                f"{images_repr}{context_repr}{meta_repr})")
+                f"{context_repr}{meta_repr})")