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

autobyteus/agent/message/context_file.py

@@ -3,6 +3,7 @@ import os
 import logging
 from typing import Optional, Dict, Any
 from dataclasses import dataclass, field
+from urllib.parse import urlparse
 
 from .context_file_type import ContextFileType
 
@@ -12,10 +13,9 @@ logger = logging.getLogger(__name__)
 class ContextFile:
     """
     Represents a single context file provided to an agent.
-    This is a simple dataclass, deferring path validation and file access
-    to input processors.
+    The 'uri' can be a local file path or a network URL.
     """
-    path: str
+    uri: str
     file_type: ContextFileType = ContextFileType.UNKNOWN
     file_name: Optional[str] = None
     metadata: Dict[str, Any] = field(default_factory=dict)
@@ -25,33 +25,33 @@ class ContextFile:
         Called after the dataclass's __init__ method.
         Used here to infer file_name and file_type if not provided or UNKNOWN.
         """
-        if self.file_name is None and self.path:
+        if not isinstance(self.uri, str) or not self.uri:
+            raise TypeError(f"ContextFile uri must be a non-empty string, got {type(self.uri)}")
+
+        if self.file_name is None:
             try:
-                self.file_name = os.path.basename(self.path)
+                # Use urlparse to correctly handle both URLs and local paths
+                parsed_path = urlparse(self.uri).path
+                self.file_name = os.path.basename(parsed_path)
             except Exception as e:
-                logger.warning(f"Could not determine basename for path '{self.path}': {e}")
+                logger.warning(f"Could not determine basename for uri '{self.uri}': {e}")
                 self.file_name = "unknown_file"
 
-        if self.file_type == ContextFileType.UNKNOWN and self.path:
-            inferred_type = ContextFileType.from_path(self.path)
+        if self.file_type == ContextFileType.UNKNOWN:
+            inferred_type = ContextFileType.from_path(self.uri)
             if inferred_type != ContextFileType.UNKNOWN:
                 self.file_type = inferred_type
-                logger.debug(f"Inferred file type for '{self.path}' as {self.file_type.value}")
+                logger.debug(f"Inferred file type for '{self.uri}' as {self.file_type.value}")
             else:
-                logger.debug(f"Could not infer specific file type for '{self.path}', remaining UNKNOWN.")
-        
-        # Ensure path is a string
-        if not isinstance(self.path, str):
-            # This ideally should be caught by type hints earlier, but as a runtime safeguard:
-            raise TypeError(f"ContextFile path must be a string, got {type(self.path)}")
-            
+                logger.debug(f"Could not infer specific file type for '{self.uri}', remaining UNKNOWN.")
+
         if logger.isEnabledFor(logging.DEBUG):
-            logger.debug(f"ContextFile initialized: path='{self.path}', type='{self.file_type.value}', name='{self.file_name}'")
+            logger.debug(f"ContextFile initialized: uri='{self.uri}', type='{self.file_type.value}', name='{self.file_name}'")
 
     def to_dict(self) -> Dict[str, Any]:
         """Serializes the ContextFile to a dictionary."""
         return {
-            "path": self.path,
+            "uri": self.uri,
             "file_type": self.file_type.value, # Serialize enum to its value
             "file_name": self.file_name,
             "metadata": self.metadata,
@@ -60,23 +60,23 @@ class ContextFile:
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> 'ContextFile':
         """Deserializes a ContextFile from a dictionary."""
-        if not isinstance(data.get("path"), str):
-            raise ValueError("ContextFile 'path' in dictionary must be a string.")
-        
+        if not isinstance(data.get("uri"), str):
+            raise ValueError("ContextFile 'uri' in dictionary must be a string.")
+
         file_type_str = data.get("file_type", ContextFileType.UNKNOWN.value)
         try:
             file_type = ContextFileType(file_type_str)
         except ValueError:
             logger.warning(f"Invalid file_type string '{file_type_str}' in ContextFile data. Defaulting to UNKNOWN.")
             file_type = ContextFileType.UNKNOWN
-            
+
         return cls(
-            path=data["path"],
+            uri=data["uri"],
             file_type=file_type,
             file_name=data.get("file_name"),
             metadata=data.get("metadata", {})
         )
 
     def __repr__(self) -> str:
-        return (f"ContextFile(path='{self.path}', file_name='{self.file_name}', "
+        return (f"ContextFile(uri='{self.uri}', file_name='{self.file_name}', "
                 f"file_type='{self.file_type.value}', metadata_keys={list(self.metadata.keys())})")

autobyteus/agent/message/context_file_type.py

@@ -1,5 +1,6 @@
 from enum import Enum
 import os
+from urllib.parse import urlparse
 
 class ContextFileType(str, Enum):
     """
@@ -23,19 +24,25 @@ class ContextFileType(str, Enum):
     UNKNOWN = "unknown"    # Fallback for unrecognized types
 
     @classmethod
-    def from_path(cls, file_path: str) -> 'ContextFileType':
+    def from_path(cls, uri: str) -> 'ContextFileType':
         """
-        Infers the ContextFileType from a file path based on its extension.
+        Infers the ContextFileType from a file path or URL based on its extension.
         """
-        if not file_path or not isinstance(file_path, str):
+        if not uri or not isinstance(uri, str):
             return cls.UNKNOWN
-        
-        _, extension = os.path.splitext(file_path.lower())
-        
+
+        try:
+            # Parse the URI to handle both file paths and URLs gracefully
+            parsed_path = urlparse(uri).path
+            _, extension = os.path.splitext(parsed_path.lower())
+        except Exception:
+            # Fallback for malformed URIs
+            _, extension = os.path.splitext(uri.lower())
+
         if extension == ".txt":
             return cls.TEXT
         elif extension == ".md":
-            return cls.MARKDOWN 
+            return cls.MARKDOWN
         elif extension == ".pdf":
             return cls.PDF
         elif extension == ".docx":
@@ -61,9 +68,23 @@ class ContextFileType(str, Enum):
         elif extension in [".mp4", ".mov", ".avi", ".mkv", ".webm"]:
             return cls.VIDEO
         elif extension in [".png", ".jpg", ".jpeg", ".gif", ".webp"]:
-            return cls.IMAGE 
+            return cls.IMAGE
         else:
             return cls.UNKNOWN
 
+    @classmethod
+    def get_readable_text_types(cls) -> list['ContextFileType']:
+        """Returns a list of file types that can be read as plain text for context."""
+        return [
+            cls.TEXT,
+            cls.MARKDOWN,
+            cls.JSON,
+            cls.XML,
+            cls.HTML,
+            cls.PYTHON,
+            cls.JAVASCRIPT,
+            cls.CSV,
+        ]
+
     def __str__(self) -> str:
         return self.value

autobyteus/agent/message/multimodal_message_builder.py

@@ -0,0 +1,47 @@
+# file: autobyteus/autobyteus/agent/message/multimodal_message_builder.py
+import logging
+
+from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
+from autobyteus.agent.message.context_file_type import ContextFileType
+from autobyteus.llm.user_message import LLMUserMessage
+
+logger = logging.getLogger(__name__)
+
+def build_llm_user_message(agent_input_user_message: AgentInputUserMessage) -> LLMUserMessage:
+    """
+    Builds an LLMUserMessage from an AgentInputUserMessage by categorizing its context files.
+
+    This function iterates through the context files, sorting URIs for images, audio, and video
+    into the appropriate fields of the LLMUserMessage. It ignores other file types for now.
+
+    Args:
+        agent_input_user_message: The user input message containing content and context files.
+
+    Returns:
+        An LLMUserMessage ready to be sent to the LLM.
+    """
+    image_urls = []
+    audio_urls = []
+    video_urls = []
+
+    if agent_input_user_message.context_files:
+        for context_file in agent_input_user_message.context_files:
+            file_type = context_file.file_type
+            if file_type == ContextFileType.IMAGE:
+                image_urls.append(context_file.uri)
+            elif file_type == ContextFileType.AUDIO:
+                audio_urls.append(context_file.uri)
+            elif file_type == ContextFileType.VIDEO:
+                video_urls.append(context_file.uri)
+            else:
+                logger.debug(f"Ignoring non-media context file of type '{file_type.value}' during LLM message build: {context_file.uri}")
+
+    llm_user_message = LLMUserMessage(
+        content=agent_input_user_message.content,
+        image_urls=image_urls if image_urls else None,
+        audio_urls=audio_urls if audio_urls else None,
+        video_urls=video_urls if video_urls else None
+    )
+
+    logger.info(f"Built LLMUserMessage with {len(image_urls)} images, {len(audio_urls)} audio, {len(video_urls)} video files.")
+    return llm_user_message

autobyteus/agent/streaming/stream_event_payloads.py

@@ -20,12 +20,18 @@ class AssistantChunkData(BaseStreamPayload):
     reasoning: Optional[str] = None
     is_complete: bool
     usage: Optional[TokenUsage] = None 
+    image_urls: Optional[List[str]] = None
+    audio_urls: Optional[List[str]] = None
+    video_urls: Optional[List[str]] = None
 
 
 class AssistantCompleteResponseData(BaseStreamPayload):
     content: str
     reasoning: Optional[str] = None
     usage: Optional[TokenUsage] = None 
+    image_urls: Optional[List[str]] = None
+    audio_urls: Optional[List[str]] = None
+    video_urls: Optional[List[str]] = None
 
 class ToolInteractionLogEntryData(BaseStreamPayload):
     log_entry: str
@@ -102,14 +108,20 @@ def create_assistant_chunk_data(chunk_obj: Any) -> AssistantChunkData:
             content=str(getattr(chunk_obj, 'content', '')),
             reasoning=getattr(chunk_obj, 'reasoning', None),
             is_complete=bool(getattr(chunk_obj, 'is_complete', False)),
-            usage=parsed_usage
+            usage=parsed_usage,
+            image_urls=getattr(chunk_obj, 'image_urls', None),
+            audio_urls=getattr(chunk_obj, 'audio_urls', None),
+            video_urls=getattr(chunk_obj, 'video_urls', None)
         )
     elif isinstance(chunk_obj, dict): 
          return AssistantChunkData(
             content=str(chunk_obj.get('content', '')),
             reasoning=chunk_obj.get('reasoning', None),
             is_complete=bool(chunk_obj.get('is_complete', False)),
-            usage=parsed_usage
+            usage=parsed_usage,
+            image_urls=chunk_obj.get('image_urls', None),
+            audio_urls=chunk_obj.get('audio_urls', None),
+            video_urls=chunk_obj.get('video_urls', None)
         )
     raise ValueError(f"Cannot create AssistantChunkData from {type(chunk_obj)}")
 
@@ -136,13 +148,19 @@ def create_assistant_complete_response_data(complete_resp_obj: Any) -> Assistant
         return AssistantCompleteResponseData(
             content=str(getattr(complete_resp_obj, 'content', '')),
             reasoning=getattr(complete_resp_obj, 'reasoning', None),
-            usage=parsed_usage
+            usage=parsed_usage,
+            image_urls=getattr(complete_resp_obj, 'image_urls', None),
+            audio_urls=getattr(complete_resp_obj, 'audio_urls', None),
+            video_urls=getattr(complete_resp_obj, 'video_urls', None)
         )
     elif isinstance(complete_resp_obj, dict): 
         return AssistantCompleteResponseData(
             content=str(complete_resp_obj.get('content', '')),
             reasoning=complete_resp_obj.get('reasoning', None),
-            usage=parsed_usage
+            usage=parsed_usage,
+            image_urls=complete_resp_obj.get('image_urls', None),
+            audio_urls=complete_resp_obj.get('audio_urls', None),
+            video_urls=complete_resp_obj.get('video_urls', None)
         )
     raise ValueError(f"Cannot create AssistantCompleteResponseData from {type(complete_resp_obj)}")
 
@@ -177,3 +195,4 @@ def create_system_task_notification_data(notification_data_dict: Any) -> SystemT
     if isinstance(notification_data_dict, dict):
         return SystemTaskNotificationData(**notification_data_dict)
     raise ValueError(f"Cannot create SystemTaskNotificationData from {type(notification_data_dict)}")
+

autobyteus/agent/system_prompt_processor/tool_manifest_injector_processor.py

@@ -47,6 +47,9 @@ class ToolManifestInjectorProcessor(BaseSystemPromptProcessor):
         llm_provider = None
         if context.llm_instance and context.llm_instance.model:
             llm_provider = context.llm_instance.model.provider
+        
+        # Retrieve the override flag from the agent's configuration.
+        use_xml_tool_format = context.config.use_xml_tool_format
 
         # Generate the manifest string for the 'tools' variable.
         tools_manifest: str
@@ -59,10 +62,11 @@ class ToolManifestInjectorProcessor(BaseSystemPromptProcessor):
             ]
 
             try:
-                # Delegate manifest generation to the provider, which now handles all format logic.
+                # Delegate manifest generation to the provider, passing the override flag.
                 tools_manifest = self._manifest_provider.provide(
                     tool_definitions=tool_definitions,
-                    provider=llm_provider
+                    provider=llm_provider,
+                    use_xml_tool_format=use_xml_tool_format
                 )
             except Exception as e:
                 logger.exception(f"An unexpected error occurred during tool manifest generation for agent '{agent_id}': {e}")

autobyteus/agent/tool_invocation.py

@@ -2,7 +2,14 @@
 import uuid
 import hashlib
 import json
-from typing import Optional, Dict, Any
+import logging
+from typing import Optional, Dict, Any, List, TYPE_CHECKING
+from dataclasses import dataclass, field
+
+if TYPE_CHECKING:
+    from autobyteus.agent.events import ToolResultEvent
+
+logger = logging.getLogger(__name__)
 
 class ToolInvocation:
     def __init__(self, name: Optional[str] = None, arguments: Optional[Dict[str, Any]] = None, id: Optional[str] = None):
@@ -33,11 +40,15 @@ class ToolInvocation:
         """
         # Create a canonical representation of the arguments
         # sort_keys=True ensures that the order of keys doesn't change the hash
-        canonical_args = json.dumps(arguments, sort_keys=True, separators=(',', ':'))
+        # ensure_ascii=False is critical for cross-language compatibility with JS
+        canonical_args = json.dumps(arguments, sort_keys=True, separators=(',', ':'), ensure_ascii=False)
         
         # Create a string to hash
         hash_string = f"{name}:{canonical_args}"
         
+        # --- ADDED LOGGING ---
+        logger.debug(f"Generating tool invocation ID from hash_string: '{hash_string}'")
+        
         # Use SHA256 for a robust hash
         sha256_hash = hashlib.sha256(hash_string.encode('utf-8')).hexdigest()
         
@@ -54,3 +65,17 @@ class ToolInvocation:
     def __repr__(self) -> str:
         return (f"ToolInvocation(id='{self.id}', name='{self.name}', "
                 f"arguments={self.arguments})")
+
+
+@dataclass
+class ToolInvocationTurn:
+    """
+    A data class to encapsulate the state of a multi-tool invocation turn.
+    Its existence in the agent's state signifies that a multi-tool turn is active.
+    """
+    invocations: List[ToolInvocation]
+    results: List['ToolResultEvent'] = field(default_factory=list)
+
+    def is_complete(self) -> bool:
+        """Checks if all expected tool results have been collected."""
+        return len(self.results) >= len(self.invocations)

autobyteus/agent_team/agent_team_builder.py

@@ -45,6 +45,7 @@ class AgentTeamBuilder:
         self._coordinator_config: Optional[AgentConfig] = None
         self._added_node_names: Set[str] = set()
         self._task_notification_mode: TaskNotificationMode = TaskNotificationMode.AGENT_MANUAL_NOTIFICATION
+        self._use_xml_tool_format: Optional[bool] = None
         logger.info(f"AgentTeamBuilder initialized for team: '{self._name}'.")
 
     def add_agent_node(self, agent_config: AgentConfig, dependencies: Optional[List[NodeDefinition]] = None) -> 'AgentTeamBuilder':
@@ -142,6 +143,25 @@ class AgentTeamBuilder:
         logger.debug(f"Task notification mode set to '{mode.value}'.")
         return self
 
+    def set_use_xml_tool_format(self, use_xml: bool) -> 'AgentTeamBuilder':
+        """
+        Sets the team-level override for using XML tool format.
+
+        If set, this will override the setting on all individual agents within the team.
+
+        Args:
+            use_xml: If True, forces the team to use XML format for tool
+                     definitions and parsing.
+
+        Returns:
+            The builder instance for fluent chaining.
+        """
+        if not isinstance(use_xml, bool):
+            raise TypeError("use_xml must be a boolean.")
+        self._use_xml_tool_format = use_xml
+        logger.debug(f"Team-level XML tool format override set to '{use_xml}'.")
+        return self
+
     def build(self) -> AgentTeam:
         """
         Constructs and returns the final AgentTeam instance using the
@@ -175,7 +195,8 @@ class AgentTeamBuilder:
             role=self._role,
             nodes=tuple(final_nodes),
             coordinator_node=coordinator_node_instance,
-            task_notification_mode=self._task_notification_mode
+            task_notification_mode=self._task_notification_mode,
+            use_xml_tool_format=self._use_xml_tool_format
         )
         
         logger.info(f"AgentTeamConfig created successfully. Name: '{team_config.name}'. Total nodes: {len(final_nodes)}. Coordinator: '{coordinator_node_instance.name}'.")

autobyteus/agent_team/bootstrap_steps/agent_configuration_preparation_step.py

@@ -15,8 +15,8 @@ logger = logging.getLogger(__name__)
 class AgentConfigurationPreparationStep(BaseAgentTeamBootstrapStep):
     """
     Bootstrap step to prepare the final, immutable configuration for every
-    agent in the team. It injects team-specific context and applies the final
-    coordinator prompt. It no longer injects tools.
+    agent in the team. It injects team-specific context, applies team-level
+    settings like tool format overrides, and prepares the final coordinator prompt.
     """
     async def execute(self, context: 'AgentTeamContext', phase_manager: 'AgentTeamPhaseManager') -> bool:
         team_id = context.team_id
@@ -44,6 +44,13 @@ class AgentConfigurationPreparationStep(BaseAgentTeamBootstrapStep):
                 
                 final_config = node_definition.copy()
 
+                # --- Team-level Setting Propagation ---
+                # If the team config specifies a tool format, it overrides any agent-level setting.
+                if context.config.use_xml_tool_format is not None:
+                    final_config.use_xml_tool_format = context.config.use_xml_tool_format
+                    logger.debug(f"Team '{team_id}': Applied team-level use_xml_tool_format={final_config.use_xml_tool_format} to agent '{unique_name}'.")
+
+
                 # --- Shared Context Injection ---
                 # The shared context is injected into the initial_custom_data dictionary,
                 # which is then used by the AgentFactory to create the AgentRuntimeState.

autobyteus/agent_team/context/agent_team_config.py

@@ -20,6 +20,7 @@ class AgentTeamConfig:
     coordinator_node: TeamNodeConfig
     role: Optional[str] = None
     task_notification_mode: TaskNotificationMode = TaskNotificationMode.AGENT_MANUAL_NOTIFICATION
+    use_xml_tool_format: Optional[bool] = None
 
     def __post_init__(self):
         if not self.name or not isinstance(self.name, str):

autobyteus/agent_team/context/agent_team_runtime_state.py

@@ -14,7 +14,6 @@ if TYPE_CHECKING:
     from autobyteus.agent_team.context.team_manager import TeamManager
     from autobyteus.agent_team.streaming.agent_event_multiplexer import AgentEventMultiplexer
     from autobyteus.task_management.base_task_board import BaseTaskBoard
-    from autobyteus.task_management.artifacts.artifact_manifest import ArtifactManifest
     from autobyteus.agent_team.task_notification.system_event_driven_agent_task_notifier import SystemEventDrivenAgentTaskNotifier
 
 logger = logging.getLogger(__name__)
@@ -40,7 +39,6 @@ class AgentTeamRuntimeState:
     
     # Dynamic planning and artifact state
     task_board: Optional['BaseTaskBoard'] = None
-    artifact_registry: Dict[str, 'ArtifactManifest'] = field(default_factory=dict)
 
     def __post_init__(self):
         if not self.team_id or not isinstance(self.team_id, str):

autobyteus/llm/api/autobyteus_llm.py

@@ -4,6 +4,7 @@ from autobyteus.llm.models import LLMModel
 from autobyteus.llm.utils.llm_config import LLMConfig
 from autobyteus.llm.utils.token_usage import TokenUsage
 from autobyteus.llm.utils.response_types import CompleteResponse, ChunkResponse
+from autobyteus.llm.user_message import LLMUserMessage
 from autobyteus_llm_client.client import AutobyteusClient
 import logging
 import uuid
@@ -12,36 +13,35 @@ logger = logging.getLogger(__name__)
 
 class AutobyteusLLM(BaseLLM):
     def __init__(self, model: LLMModel, llm_config: LLMConfig):
-        # The host URL is now passed via the model object.
         if not model.host_url:
             raise ValueError("AutobyteusLLM requires a host_url to be set in its LLMModel object.")
 
         super().__init__(model=model, llm_config=llm_config)
         
-        # Instantiate the client with the specific host for this model.
         self.client = AutobyteusClient(server_url=self.model.host_url)
         self.conversation_id = str(uuid.uuid4())
         logger.info(f"AutobyteusLLM initialized for model '{self.model.model_identifier}' with conversation ID: {self.conversation_id}")
 
     async def _send_user_message_to_llm(
         self,
-        user_message: str,
-        image_urls: Optional[List[str]] = None,
+        user_message: LLMUserMessage,
         **kwargs
     ) -> CompleteResponse:
         self.add_user_message(user_message)
         try:
             response = await self.client.send_message(
                 conversation_id=self.conversation_id,
-                model_name=self.model.name, # Use `name` as it's the original model name for the API
-                user_message=user_message,
-                image_urls=image_urls
+                model_name=self.model.name,
+                user_message=user_message.content,
+                image_urls=user_message.image_urls,
+                audio_urls=user_message.audio_urls,
+                video_urls=user_message.video_urls
             )
             
             assistant_message = response['response']
             self.add_assistant_message(assistant_message)
             
-            token_usage_data = response.get('token_usage', {})
+            token_usage_data = response.get('token_usage') or {}
             token_usage = TokenUsage(
                 prompt_tokens=token_usage_data.get('prompt_tokens', 0),
                 completion_tokens=token_usage_data.get('completion_tokens', 0),
@@ -59,8 +59,7 @@ class AutobyteusLLM(BaseLLM):
 
     async def _stream_user_message_to_llm(
         self,
-        user_message: str,
-        image_urls: Optional[List[str]] = None,
+        user_message: LLMUserMessage,
         **kwargs
     ) -> AsyncGenerator[ChunkResponse, None]:
         self.add_user_message(user_message)
@@ -69,36 +68,38 @@ class AutobyteusLLM(BaseLLM):
         try:
             async for chunk in self.client.stream_message(
                 conversation_id=self.conversation_id,
-                model_name=self.model.name, # Use `name` for the API call
-                user_message=user_message,
-                image_urls=image_urls
+                model_name=self.model.name,
+                user_message=user_message.content,
+                image_urls=user_message.image_urls,
+                audio_urls=user_message.audio_urls,
+                video_urls=user_message.video_urls
             ):
                 if 'error' in chunk:
                     raise RuntimeError(chunk['error'])
                 
                 content = chunk.get('content', '')
-                complete_response += content
+                if content:
+                    complete_response += content
+
                 is_complete = chunk.get('is_complete', False)
-                
-                # If this is the final chunk, include token usage
+                token_usage = None
                 if is_complete:
-                    token_usage = None
-                    if chunk.get('token_usage'):
-                        token_usage = TokenUsage(
-                            prompt_tokens=chunk['token_usage'].get('prompt_tokens', 0),
-                            completion_tokens=chunk['token_usage'].get('completion_tokens', 0),
-                            total_tokens=chunk['token_usage'].get('total_tokens', 0)
-                        )
-                    yield ChunkResponse(
-                        content=content,
-                        is_complete=True,
-                        usage=token_usage
-                    )
-                else:
-                    yield ChunkResponse(
-                        content=content,
-                        is_complete=False
+                    token_usage_data = chunk.get('token_usage') or {}
+                    token_usage = TokenUsage(
+                        prompt_tokens=token_usage_data.get('prompt_tokens', 0),
+                        completion_tokens=token_usage_data.get('completion_tokens', 0),
+                        total_tokens=token_usage_data.get('total_tokens', 0)
                     )
+
+                yield ChunkResponse(
+                    content=content,
+                    reasoning=chunk.get('reasoning'),
+                    is_complete=is_complete,
+                    image_urls=chunk.get('image_urls', []),
+                    audio_urls=chunk.get('audio_urls', []),
+                    video_urls=chunk.get('video_urls', []),
+                    usage=token_usage
+                )
             
             self.add_assistant_message(complete_response)
         except Exception as e:
@@ -116,7 +117,6 @@ class AutobyteusLLM(BaseLLM):
             await self.client.close()
 
     async def _handle_error_cleanup(self):
-        """Handle cleanup operations after errors"""
         try:
             await self.cleanup()
         except Exception as cleanup_error:

autobyteus/llm/api/bedrock_llm.py

@@ -9,10 +9,10 @@ from autobyteus.llm.utils.llm_config import LLMConfig
 from autobyteus.llm.utils.messages import MessageRole, Message
 from autobyteus.llm.utils.token_usage import TokenUsage
 from autobyteus.llm.utils.response_types import CompleteResponse, ChunkResponse
+from autobyteus.llm.user_message import LLMUserMessage
 
 class BedrockLLM(BaseLLM):
     def __init__(self, model: LLMModel = None, llm_config: LLMConfig = None):
-        # Provide defaults if not specified
         if model is None:
             model = LLMModel.BEDROCK_CLAUDE_3_5_SONNET_API
         if llm_config is None:
@@ -43,14 +43,17 @@ class BedrockLLM(BaseLLM):
         except Exception as e:
             raise ValueError(f"Failed to initialize Bedrock client: {str(e)}")
     
-    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:
         self.add_user_message(user_message)
         
+        # NOTE: This implementation does not yet support multimodal inputs for Bedrock.
+        # It will only send the text content.
+        
         request_body = json.dumps({
             "anthropic_version": "bedrock-2023-05-31",
             "max_tokens": 1000,
             "temperature": 0,
-            "messages": [msg.to_dict() for msg in self.messages],
+            "messages": [msg.to_dict() for msg in self.messages if msg.role != MessageRole.SYSTEM],
             "system": self.system_message if self.system_message else ""
         })
 
@@ -79,6 +82,11 @@ class BedrockLLM(BaseLLM):
             raise ValueError(f"Bedrock API error: {error_code} - {error_message}")
         except Exception as e:
             raise ValueError(f"Error in Bedrock API call: {str(e)}")
-    
+
+    async def _stream_user_message_to_llm(self, user_message: LLMUserMessage, **kwargs) -> AsyncGenerator[ChunkResponse, None]:
+        # Placeholder for future implementation
+        response = await self._send_user_message_to_llm(user_message, **kwargs)
+        yield ChunkResponse(content=response.content, is_complete=True, usage=response.usage)
+
     async def cleanup(self):
-        super().cleanup()
+        await super().cleanup()