autobyteus 1.0.6__py3-none-any.whl → 1.1.1__py3-none-any.whl

autobyteus/agent/agent.py

@@ -1,231 +1,106 @@
+# file: autobyteus/autobyteus/agent/agent.py
 import asyncio
 import logging
-from typing import List, Optional
-from autobyteus.agent.response_parser.tool_usage_command_parser import ToolUsageCommandParser
-from autobyteus.events.event_emitter import EventEmitter
-from autobyteus.llm.base_llm import BaseLLM
-from autobyteus.tools.base_tool import BaseTool
-from autobyteus.prompt.prompt_builder import PromptBuilder
-from autobyteus.events.event_types import EventType
-from autobyteus.agent.status import AgentStatus
-from autobyteus.conversation.user_message import UserMessage
-from autobyteus.conversation.conversation import Conversation
+from typing import AsyncIterator, Optional, List, Any, Dict, TYPE_CHECKING 
+
+from autobyteus.agent.runtime.agent_runtime import AgentRuntime
+from autobyteus.agent.context.phases import AgentOperationalPhase 
+from autobyteus.agent.message.agent_input_user_message import AgentInputUserMessage
+from autobyteus.agent.message.inter_agent_message import InterAgentMessage
+from autobyteus.agent.events import UserMessageReceivedEvent, InterAgentMessageReceivedEvent, ToolExecutionApprovalEvent, BaseEvent 
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext 
 
 logger = logging.getLogger(__name__)
 
-class Agent(EventEmitter):
-    def __init__(self, role: str, llm: BaseLLM, tools: Optional[List[BaseTool]] = None,
-                 agent_id=None,
-                 prompt_builder: Optional[PromptBuilder] = None,
-                 initial_user_message: Optional[UserMessage] = None):
-        super().__init__()
-        self.role = role
-        self.llm = llm
-        self.tools = tools or []
-        self.tool_usage_response_parser = ToolUsageCommandParser() if self.tools else None
-        self.conversation = None
-        self.agent_id = agent_id or f"{self.role}-001"
-        self.status = AgentStatus.NOT_STARTED
-        self._run_task = None
-        self._queues_initialized = False
-        self.task_completed = None
-        self.prompt_builder = prompt_builder
-        self.initial_user_message = initial_user_message
-
-        if not self.prompt_builder and not self.initial_user_message:
-            raise ValueError("Either prompt_builder or initial_user_message must be provided")
-
-        if self.tools:
-            self.set_agent_id_on_tools()
-            
-        logger.info(f"StandaloneAgent initialized with role: {self.role}, agent_id: {self.agent_id}")
-
-    def _initialize_queues(self):
-        if not self._queues_initialized:
-            self.tool_result_messages = asyncio.Queue()
-            self.user_messages = asyncio.Queue()
-            self._queues_initialized = True
-            logger.info(f"Queues initialized for agent {self.role}")
-
-    def _initialize_task_completed(self):
-        if self.task_completed is None:
-            self.task_completed = asyncio.Event()
-            logger.info(f"task_completed Event initialized for agent {self.role}")
-
-    def get_task_completed(self):
-        if self.task_completed is None:
-            raise RuntimeError("task_completed Event accessed before initialization")
-        return self.task_completed
-
-    async def run(self):
-        try:
-            logger.info(f"Starting execution for agent: {self.role}")
-            self._initialize_queues()
-            self._initialize_task_completed()
-            await self.initialize_conversation()
-
-            user_message_handler = asyncio.create_task(self.handle_user_messages())
-            tool_result_handler = asyncio.create_task(self.handle_tool_result_messages())
-
-            # Once everything is ready, set the status to RUNNING
-            self.status = AgentStatus.RUNNING
-
-            await asyncio.gather(user_message_handler, tool_result_handler)
-
-        except Exception as e:
-            logger.error(f"Error in agent {self.role} execution: {str(e)}")
-            self.status = AgentStatus.ERROR
-        finally:
-            self.status = AgentStatus.ENDED
-            await self.cleanup()
-
-    async def handle_user_messages(self):
-        logger.info(f"Agent {self.role} started handling user messages")
-        while not self.task_completed.is_set() and self.status == AgentStatus.RUNNING:
-            try:
-                user_message: UserMessage = await asyncio.wait_for(self.user_messages.get(), timeout=1.0)
-                logger.info(f"Agent {self.role} handling user message")
-                response = await self.conversation.send_user_message(user_message.content, user_message.file_paths)
-                await self.process_llm_response(response)
-            except asyncio.TimeoutError:
-                continue
-            except asyncio.CancelledError:
-                logger.info(f"User message handler for agent {self.role} cancelled")
-                break
-            except Exception as e:
-                logger.error(f"Error handling user message for agent {self.role}: {str(e)}")
-
-    async def receive_user_message(self, message: UserMessage):
-        """
-        This method gracefully waits for the agent to become RUNNING
-        if it's in the process of starting up, ensuring the queues are
-        initialized before we put a message into them.
-        """
-        logger.info(f"Agent {self.agent_id} received user message")
-
-        # If the agent is not started (or ended), begin the start process
-        if self.status in [AgentStatus.NOT_STARTED, AgentStatus.ENDED]:
-            self.start()
-
-        # If the agent is still starting, wait until it transitions to RUNNING
-        while self.status == AgentStatus.STARTING:
-            await asyncio.sleep(0.1)
-
-        if self.status != AgentStatus.RUNNING:
-            logger.error(f"Agent is not in a running state: {self.status}")
-            return
+class Agent:
+    """
+    User-facing API for interacting with an agent's runtime.
+    It manages an underlying AgentRuntime instance and translates user actions
+    into events for the agent's event processing loop by submitting them
+    to AgentRuntime. Output is consumed via AgentEventStream which listens
+    to AgentExternalEventNotifier.
+    """
+
+    def __init__(self, runtime: AgentRuntime):
+        if not isinstance(runtime, AgentRuntime): # pragma: no cover
+            raise TypeError(f"Agent requires an AgentRuntime instance, got {type(runtime).__name__}")
+        
+        self._runtime: AgentRuntime = runtime
+        self.agent_id: str = self._runtime.context.agent_id 
+        
+        logger.info(f"Agent facade initialized for agent_id '{self.agent_id}'.")
+
+    @property
+    def context(self) -> 'AgentContext': 
+        return self._runtime.context
+
+    async def _submit_event_to_runtime(self, event: BaseEvent) -> None:
+        """Internal helper to submit an event to the runtime and handle startup."""
+        if not self._runtime.is_running: # pragma: no cover
+            logger.info(f"Agent '{self.agent_id}' runtime is not running. Calling start() before submitting event.")
+            self.start() 
+            await asyncio.sleep(0.05) 
+        
+        logger.debug(f"Agent '{self.agent_id}': Submitting {type(event).__name__} to runtime.")
+        await self._runtime.submit_event(event)
+
+    async def post_user_message(self, agent_input_user_message: AgentInputUserMessage) -> None:
+        if not isinstance(agent_input_user_message, AgentInputUserMessage): # pragma: no cover
+            raise TypeError(f"Agent for '{self.agent_id}' received invalid type for user_message. Expected AgentInputUserMessage, got {type(agent_input_user_message)}.")
+        
+        event = UserMessageReceivedEvent(agent_input_user_message=agent_input_user_message)
+        await self._submit_event_to_runtime(event)
 
-        # Now that we are running, safely place the message in the queue
-        await self.user_messages.put(message)
-
-    async def handle_tool_result_messages(self):
-        logger.info(f"Agent {self.role} started handling tool result messages")
-        while not self.task_completed.is_set() and self.status == AgentStatus.RUNNING:
-            try:
-                message = await asyncio.wait_for(self.tool_result_messages.get(), timeout=1.0)
-                logger.info(f"Agent {self.role} handling tool result message: {message}")
-                response = await self.conversation.send_user_message(f"Tool execution result: {message}")
-                await self.process_llm_response(response)
-            except asyncio.TimeoutError:
-                continue
-            except asyncio.CancelledError:
-                logger.info(f"Tool result handler for agent {self.role} cancelled")
-                break
-            except Exception as e:
-                logger.error(f"Error handling tool result for agent {self.role}: {str(e)}")
-
-    async def initialize_conversation(self):
-        logger.info(f"Initializing conversation for agent: {self.role}")
-        self.conversation = Conversation(self.llm)
-
-        if self.initial_user_message:
-            initial_message = self.initial_user_message
-        else:
-            prompt_content = self.prompt_builder.set_variable_value(
-                "external_tools", 
-                self._get_external_tools_section()
-            ).build()
-            initial_message = UserMessage(content=prompt_content)
-
-        logger.debug(f"Initial user message for agent {self.role}: {initial_message}")
-        initial_llm_response = await self.conversation.send_user_message(
-            initial_message.content,
-            initial_message.file_paths
-        )
-        await self.process_llm_response(initial_llm_response)
 
-    async def process_llm_response(self, response: str) -> None:
-        self.emit(EventType.ASSISTANT_RESPONSE, response=response)
+    async def post_inter_agent_message(self, inter_agent_message: InterAgentMessage) -> None:
+        if not isinstance(inter_agent_message, InterAgentMessage): # pragma: no cover
+            raise TypeError(
+                f"Agent for '{self.agent_id}' received invalid type for inter_agent_message. "
+                f"Expected InterAgentMessage, got {type(inter_agent_message).__name__}."
+            )
         
-        if self.tools and self.tool_usage_response_parser:
-            tool_invocation = self.tool_usage_response_parser.parse_response(response)
-            if tool_invocation.is_valid():
-                await self.execute_tool(tool_invocation)
-                return
-
-        logger.info(f"Assistant response for agent {self.role}: {response}")
-
-    async def execute_tool(self, tool_invocation):
-        name = tool_invocation.name
-        arguments = tool_invocation.arguments
-        logger.info(f"Agent {self.role} attempting to execute tool: {name}")
-
-        tool = next((t for t in self.tools if t.get_name() == name), None)
-        if tool:
-            try:
-                result = await tool.execute(**arguments)
-                logger.info(f"Tool '{name}' executed successfully by agent {self.role}. Result: {result}")
-                await self.tool_result_messages.put(result)
-            except Exception as e:
-                error_message = str(e)
-                logger.error(f"Error executing tool '{name}' by agent {self.role}: {error_message}")
-                await self.tool_result_messages.put(f"Error: {error_message}")
-        else:
-            logger.warning(f"Tool '{name}' not found for agent {self.role}.")
-
-    def start(self):
-        """
-        Starts the agent by creating a task that runs the main loop (run).
-        Sets the AgentStatus to STARTING to prevent message enqueuing before
-        the system is fully initialized.
-        """
-        if self.status in [AgentStatus.NOT_STARTED, AgentStatus.ENDED]:
-            logger.info(f"Starting agent {self.role}")
-            self.status = AgentStatus.STARTING
-            self._run_task = asyncio.create_task(self.run())
-        elif self.status == AgentStatus.STARTING:
-            logger.info(f"Agent {self.role} is already in STARTING state.")
-        elif self.status == AgentStatus.RUNNING:
-            logger.info(f"Agent {self.role} is already running.")
-        else:
-            logger.warning(f"Agent {self.role} is in an unexpected state: {self.status}")
-
-    def stop(self):
-        if self._run_task and not self._run_task.done():
-            self._run_task.cancel()
-
-    async def cleanup(self):
-        while not self.tool_result_messages.empty():
-            self.tool_result_messages.get_nowait()
-        while not self.user_messages.empty():
-            self.user_messages.get_nowait()
-        await self.llm.cleanup()
-        logger.info(f"Cleanup completed for agent: {self.role}")
-
-    def set_agent_id_on_tools(self):
-        if self.tools:
-            for tool in self.tools:
-                tool.set_agent_id(self.agent_id)
-
-    def _get_external_tools_section(self) -> str:
-        if not self.tools:
-            return ""
+        event = InterAgentMessageReceivedEvent(inter_agent_message=inter_agent_message)
+        await self._submit_event_to_runtime(event)
+
+
+    async def post_tool_execution_approval(self,
+                                         tool_invocation_id: str,
+                                         is_approved: bool,
+                                         reason: Optional[str] = None) -> None:
+        if not isinstance(tool_invocation_id, str) or not tool_invocation_id: # pragma: no cover
+             raise ValueError("tool_invocation_id must be a non-empty string.")
+        if not isinstance(is_approved, bool): # pragma: no cover
+            raise TypeError("is_approved must be a boolean.")
+
+        approval_event = ToolExecutionApprovalEvent(
+            tool_invocation_id=tool_invocation_id,
+            is_approved=is_approved,
+            reason=reason
+        )
+        await self._submit_event_to_runtime(approval_event)
+
+    def get_current_phase(self) -> AgentOperationalPhase: 
+        return self._runtime.current_phase_property 
+    
+    @property
+    def is_running(self) -> bool:
+        return self._runtime.is_running
+
+    def start(self) -> None: 
+        if self._runtime.is_running: # pragma: no cover
+            logger.info(f"Agent '{self.agent_id}' runtime is already running. Ignoring start command.")
+            return
             
-        external_tools_section = ""
-        for i, tool in enumerate(self.tools):
-            external_tools_section += f"  {i + 1} {tool.tool_usage()}\n\n"
-        return external_tools_section.strip()
-
-    def on_task_completed(self, *args, **kwargs):
-        logger.info(f"Task completed event received for agent: {self.role}")
-        self.task_completed.set()
+        logger.info(f"Agent '{self.agent_id}' requesting runtime to start.")
+        self._runtime.start() 
+
+    async def stop(self, timeout: float = 10.0) -> None: # pragma: no cover
+        logger.info(f"Agent '{self.agent_id}' requesting runtime to stop (timeout: {timeout}s).")
+        await self._runtime.stop(timeout=timeout) 
+
+
+    def __repr__(self) -> str:
+        phase_val = self._runtime.current_phase_property.value 
+        return f"<Agent agent_id='{self.agent_id}', current_phase='{phase_val}'>"

autobyteus/agent/bootstrap_steps/__init__.py

@@ -0,0 +1,19 @@
+# file: autobyteus/autobyteus/agent/bootstrap_steps/__init__.py
+"""
+Defines individual, self-contained steps for the agent bootstrapping process.
+These steps are orchestrated by the BootstrapAgentEventHandler.
+"""
+
+from .base_bootstrap_step import BaseBootstrapStep
+from .agent_runtime_queue_initialization_step import AgentRuntimeQueueInitializationStep # UPDATED
+from .workspace_context_initialization_step import WorkspaceContextInitializationStep
+# ToolInitializationStep is no longer a bootstrap step.
+from .system_prompt_processing_step import SystemPromptProcessingStep
+# LLMConfigFinalizationStep and LLMInstanceCreationStep removed.
+
+__all__ = [
+    "BaseBootstrapStep",
+    "AgentRuntimeQueueInitializationStep", # UPDATED
+    "WorkspaceContextInitializationStep",
+    "SystemPromptProcessingStep",
+]

autobyteus/agent/bootstrap_steps/agent_bootstrapper.py

@@ -0,0 +1,88 @@
+# file: autobyteus/autobyteus/agent/bootstrap_steps/agent_bootstrapper.py
+import logging
+from typing import TYPE_CHECKING, List, Optional
+
+from .base_bootstrap_step import BaseBootstrapStep
+from .agent_runtime_queue_initialization_step import AgentRuntimeQueueInitializationStep
+from .workspace_context_initialization_step import WorkspaceContextInitializationStep
+from .system_prompt_processing_step import SystemPromptProcessingStep
+from autobyteus.agent.events import AgentReadyEvent
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent.phases import AgentPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class AgentBootstrapper:
+    """
+    Orchestrates the agent's bootstrapping process by executing a sequence of
+    self-contained bootstrap steps.
+    """
+    def __init__(self, steps: Optional[List[BaseBootstrapStep]] = None):
+        """
+        Initializes the AgentBootstrapper.
+
+        Args:
+            steps: An optional list of bootstrap steps to execute. If not provided,
+                   a default sequence will be used.
+        """
+        if steps is None:
+            self.bootstrap_steps: List[BaseBootstrapStep] = [
+                AgentRuntimeQueueInitializationStep(),
+                WorkspaceContextInitializationStep(),
+                SystemPromptProcessingStep(),
+            ]
+            logger.debug("AgentBootstrapper initialized with default steps.")
+        else:
+            self.bootstrap_steps = steps
+            logger.debug(f"AgentBootstrapper initialized with {len(steps)} custom steps.")
+
+    async def run(self, context: 'AgentContext', phase_manager: 'AgentPhaseManager') -> bool:
+        """
+        Executes the configured sequence of bootstrap steps.
+
+        Args:
+            context: The agent's context.
+            phase_manager: The agent's phase manager.
+
+        Returns:
+            True if all steps completed successfully, False otherwise.
+        """
+        agent_id = context.agent_id
+        
+        # Set the agent phase to BOOTSTRAPPING and wait for any associated hooks.
+        await phase_manager.notify_bootstrapping_started()
+        logger.info(f"Agent '{agent_id}': AgentBootstrapper starting execution. Phase set to BOOTSTRAPPING.")
+
+        for step_index, step_instance in enumerate(self.bootstrap_steps):
+            step_name = step_instance.__class__.__name__
+            logger.debug(f"Agent '{agent_id}': Executing bootstrap step {step_index + 1}/{len(self.bootstrap_steps)}: {step_name}")
+            
+            success = await step_instance.execute(context, phase_manager)
+            
+            if not success:
+                error_message = f"Bootstrap step {step_name} failed."
+                logger.error(f"Agent '{agent_id}': {error_message} Halting bootstrap process.")
+                # The step itself is responsible for detailed error logging.
+                # We are responsible for notifying the phase manager to set the agent to an error state.
+                await phase_manager.notify_error_occurred(
+                    error_message=f"Critical bootstrap failure at {step_name}",
+                    error_details=f"Agent '{agent_id}' failed during bootstrap step '{step_name}'. Check logs for details."
+                )
+                return False
+
+        logger.info(f"Agent '{agent_id}': All bootstrap steps completed successfully. Enqueuing AgentReadyEvent.")
+        # After successful bootstrapping, enqueue the ready event.
+        if context.state.input_event_queues:
+            await context.state.input_event_queues.enqueue_internal_system_event(AgentReadyEvent())
+        else: # pragma: no cover
+            # Should not happen if AgentRuntimeQueueInitializationStep is present and successful
+            logger.critical(f"Agent '{agent_id}': Bootstrap succeeded but input queues are not available to enqueue AgentReadyEvent.")
+            await phase_manager.notify_error_occurred(
+                error_message="Input queues unavailable after bootstrap",
+                error_details=f"Agent '{agent_id}' bootstrap process seemed to succeed, but input event queues are missing."
+            )
+            return False
+            
+        return True

autobyteus/agent/bootstrap_steps/agent_runtime_queue_initialization_step.py

@@ -0,0 +1,57 @@
+# file: autobyteus/autobyteus/agent/bootstrap_steps/agent_runtime_queue_initialization_step.py
+import logging
+from typing import TYPE_CHECKING
+
+from .base_bootstrap_step import BaseBootstrapStep
+from autobyteus.agent.events import AgentErrorEvent, AgentInputEventQueueManager
+# AgentOutputDataManager is no longer initialized here.
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent.phases import AgentPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class AgentRuntimeQueueInitializationStep(BaseBootstrapStep):
+    """
+    Bootstrap step for initializing the agent's runtime INPUT event queues.
+    These queues are created within the AgentWorker's event loop.
+    Output data is now handled by emitting events via AgentExternalEventNotifier.
+    """
+    def __init__(self, input_queue_size: int = 0): # Removed output_queue_size
+        self.input_queue_size = input_queue_size
+        logger.debug(f"AgentRuntimeQueueInitializationStep initialized with input_q_size={input_queue_size}.")
+
+    async def execute(self,
+                      context: 'AgentContext',
+                      phase_manager: 'AgentPhaseManager') -> bool:
+        agent_id = context.agent_id
+        logger.info(f"Agent '{agent_id}': Executing AgentRuntimeQueueInitializationStep (for input queues).")
+
+        try:
+            if context.state.input_event_queues is not None: # Check only input queues
+                logger.warning(f"Agent '{agent_id}': Input runtime queues seem to be already initialized. Overwriting. This might indicate a logic error.")
+
+            input_queues = AgentInputEventQueueManager(queue_size=self.input_queue_size)
+            context.state.input_event_queues = input_queues
+            # context.state.output_data_queues is no longer set here.
+
+            logger.info(f"Agent '{agent_id}': AgentInputEventQueueManager initialized and set in agent state.")
+            if context.state.input_event_queues is None: # pragma: no cover
+                raise RuntimeError("Input event queue manager was not successfully set in agent state during AgentRuntimeQueueInitializationStep.")
+            
+            return True
+        except Exception as e:
+            error_message = f"Agent '{agent_id}': Critical failure during AgentRuntimeQueueInitializationStep (input queues): {e}"
+            logger.error(error_message, exc_info=True)
+            
+            # Attempt to enqueue an error event if input_event_queues was partially created
+            # This check itself might be problematic if input_queues is the thing that failed.
+            # However, if it failed *after* assigning self.input_event_queues, this might work.
+            if context.state.input_event_queues and context.state.input_event_queues.internal_system_event_queue: # pragma: no cover
+                 await context.state.input_event_queues.enqueue_internal_system_event(
+                     AgentErrorEvent(error_message=error_message, exception_details=str(e))
+                 )
+            else: # pragma: no cover
+                 logger.error(f"Agent '{agent_id}': Cannot enqueue AgentErrorEvent as input_event_queues are not available after AgentRuntimeQueueInitializationStep failure.")
+            return False

autobyteus/agent/bootstrap_steps/base_bootstrap_step.py

@@ -0,0 +1,38 @@
+# file: autobyteus/autobyteus/agent/bootstrap_steps/base_bootstrap_step.py
+import logging
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent.phases import AgentPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class BaseBootstrapStep(ABC):
+    """
+    Abstract base class for individual steps in the agent bootstrapping process.
+    Each step is responsible for a specific part of the initialization and
+    for reporting its success or failure.
+    """
+
+    @abstractmethod
+    async def execute(self,
+                      context: 'AgentContext',
+                      phase_manager: 'AgentPhaseManager') -> bool:
+        """
+        Executes the bootstrap step.
+
+        Args:
+            context: The agent's context, providing access to configuration and state.
+            phase_manager: The agent's phase manager for notifying phase transitions.
+
+        Returns:
+            True if the step completed successfully, False otherwise.
+            If False, the step is expected to have handled logging and enqueuing
+            an AgentErrorEvent.
+        """
+        raise NotImplementedError("Subclasses must implement the 'execute' method.")
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}>"

autobyteus/agent/bootstrap_steps/system_prompt_processing_step.py

@@ -0,0 +1,93 @@
+# file: autobyteus/autobyteus/agent/bootstrap_steps/system_prompt_processing_step.py
+import logging
+from typing import TYPE_CHECKING
+
+from .base_bootstrap_step import BaseBootstrapStep
+from autobyteus.agent.events import AgentErrorEvent
+from autobyteus.agent.system_prompt_processor.base_processor import BaseSystemPromptProcessor
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent.phases import AgentPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class SystemPromptProcessingStep(BaseBootstrapStep):
+    """
+    Bootstrap step for processing the agent's system prompt and setting it
+    on the pre-initialized LLM instance.
+    If any configured processor fails, this entire step is considered failed.
+    """
+    def __init__(self):
+        logger.debug("SystemPromptProcessingStep initialized.")
+
+    async def execute(self,
+                      context: 'AgentContext',
+                      phase_manager: 'AgentPhaseManager') -> bool:
+        agent_id = context.agent_id
+        # The phase is now managed by the AgentBootstrapper.
+        logger.info(f"Agent '{agent_id}': Executing SystemPromptProcessingStep.")
+
+        try:
+            # The LLM instance is now expected to be present from the start.
+            llm_instance = context.llm_instance
+            if not llm_instance:
+                raise ValueError("LLM instance not found in agent state. It must be provided in AgentConfig.")
+
+            current_system_prompt = context.config.system_prompt
+            logger.debug(f"Agent '{agent_id}': Retrieved base system prompt from agent config.")
+            
+            processor_instances = context.config.system_prompt_processors
+            tool_instances_for_processor = context.tool_instances
+
+            if not processor_instances:
+                logger.debug(f"Agent '{agent_id}': No system prompt processors configured. Using system prompt as is.")
+            else:
+                logger.debug(f"Agent '{agent_id}': Found {len(processor_instances)} configured system prompt processors. Applying sequentially.")
+                for processor_instance in processor_instances:
+                    if not isinstance(processor_instance, BaseSystemPromptProcessor):
+                        error_message = f"Agent '{agent_id}': Invalid system prompt processor configuration type: {type(processor_instance)}. Expected BaseSystemPromptProcessor."
+                        logger.error(error_message)
+                        raise TypeError(error_message)
+                    
+                    processor_name = processor_instance.get_name()
+                    try:
+                        logger.debug(f"Agent '{agent_id}': Applying system prompt processor '{processor_name}'.")
+                        current_system_prompt = processor_instance.process(
+                            system_prompt=current_system_prompt,
+                            tool_instances=tool_instances_for_processor,
+                            agent_id=agent_id,
+                            context=context
+                        )
+                        logger.info(f"Agent '{agent_id}': System prompt processor '{processor_name}' applied successfully.")
+                    except Exception as e_proc: 
+                        error_message = f"Agent '{agent_id}': Error applying system prompt processor '{processor_name}': {e_proc}"
+                        logger.error(error_message, exc_info=True)
+                        if context.state.input_event_queues:
+                            await context.state.input_event_queues.enqueue_internal_system_event(
+                                AgentErrorEvent(error_message=error_message, exception_details=str(e_proc))
+                            )
+                        return False # Signal failure of the entire step
+            
+            context.state.processed_system_prompt = current_system_prompt
+            
+            # --- New Logic: Set the prompt on the existing LLM instance ---
+            if hasattr(llm_instance, 'configure_system_prompt') and callable(getattr(llm_instance, 'configure_system_prompt')):
+                llm_instance.configure_system_prompt(current_system_prompt)
+                logger.info(f"Agent '{agent_id}': Final processed system prompt configured on LLM instance. Final length: {len(current_system_prompt)}.")
+            else:
+                # This path should ideally not be taken if all LLMs inherit from the updated BaseLLM.
+                # It's kept as a fallback with a strong warning.
+                logger.warning(f"Agent '{agent_id}': LLM instance ({llm_instance.__class__.__name__}) does not have a 'configure_system_prompt' method. "
+                               f"The system prompt cannot be dynamically updated on the LLM instance after initialization. This may lead to incorrect agent behavior.")
+
+            logger.info(f"Agent '{agent_id}': Final processed system prompt:\n---\n{current_system_prompt}\n---")
+            return True
+        except Exception as e: # Catches other errors in the step setup itself
+            error_message = f"Agent '{agent_id}': Critical failure during system prompt processing step: {e}"
+            logger.error(error_message, exc_info=True)
+            if context.state.input_event_queues:
+                await context.input_event_queues.enqueue_internal_system_event(
+                    AgentErrorEvent(error_message=error_message, exception_details=str(e))
+                )
+            return False