autobyteus 1.0.6__tar.gz → 1.1.0__tar.gz

{autobyteus-1.0.6 → autobyteus-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.0.6
+Version: 1.1.0
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -27,6 +27,8 @@ Requires-Dist: anthropic==0.37.1
 Requires-Dist: Jinja2
 Requires-Dist: ollama==0.4.5
 Requires-Dist: mistral_common
+Requires-Dist: certifi==2025.4.26
+Requires-Dist: numpy==2.2.5
 Requires-Dist: aiohttp
 Requires-Dist: autobyteus-llm-client==1.1.0
 Requires-Dist: brui-core==1.0.8
@@ -66,6 +68,18 @@ Dynamic: summary
 
 Autobyteus is an open-source coding assistance tool designed to enhance the software development workflow by making it context-aware. Each step in the workflow is interactive through a user-friendly interface, incorporating the entire software development lifecycle into each stage.
 
+## Architecture
+
+Autobyteus is built with a modular, event-driven architecture designed for extensibility and clear separation of concerns. The key components are:
+
+-   **Agent Core**: The heart of the system, comprising an `Agent` facade that provides the primary user-facing API. This facade communicates with an `AgentRuntime`, which manages an `AgentWorker` running in a dedicated thread. This design ensures non-blocking agent operations.
+-   **Context & Configuration**: Agent behavior is defined through a clear configuration (`AgentConfig`) and its dynamic state is managed in `AgentRuntimeState`. These are bundled into a comprehensive `AgentContext` that is available to all components during runtime, providing a single source of truth for an agent's status and capabilities.
+-   **Event-Driven System**: Agents operate on an internal event loop. Actions (like receiving user messages or tool results) are translated into events and placed on internal queues. `EventHandlers` process these events, containing the core logic for how an agent thinks and acts. This decouples logic and makes the system easy to extend.
+-   **Pluggable Processors**: The framework uses a pipeline of processors to modify data at key stages. `SystemPromptProcessors` dynamically build the final system prompt (e.g., by injecting tool definitions), `InputProcessors` preprocess user messages, and `LLMResponseProcessors` parse outputs from the language model (e.g., to detect tool usage).
+-   **Tooling**: Agents can be extended with `Tools`, which are self-contained capabilities that can be called by the LLM. The system includes built-in tools (like `SendMessageTo` for inter-agent communication) and supports custom tools.
+-   **Multi-Agent Systems**: The `AgentGroup` and `AgenticWorkflow` abstractions provide powerful, high-level APIs for orchestrating multiple agents to collaborate on complex tasks.
+-   **Remote Agents**: Built-in RPC capabilities allow for communication with agents running in separate processes or on different machines, enabling distributed agent systems.
+
 ## Features
 
 - **Context-Aware Workflows**: Each step in the development process interacts with large language models to provide relevant assistance.
@@ -74,7 +88,11 @@ Autobyteus is an open-source coding assistance tool designed to enhance the soft
 
 ## Knowledge Base
 
-A significant part of Autobytus is our custom-designed knowledge base focused on software and application development. The knowledge base is structured to support the entire development process, with particular emphasis on requirement engineering, which is crucial for successful project outcomes.
+A significant part of Autobyteus is our custom-designed knowledge base focused on software and application development. The knowledge base is structured to support the entire development process, with particular emphasis on requirement engineering, which is crucial for successful project outcomes.
+
+## Requirements
+
+-   **Python Version**: Python 3.11 is the recommended and tested version for this project. Using newer versions of Python may result in dependency conflicts when installing the required packages. For a stable and tested environment, please use Python 3.11.
 
 ## Getting Started
 

autobyteus-1.1.0/README.md

@@ -0,0 +1,91 @@
+# Autobyteus
+
+Autobyteus is an open-source coding assistance tool designed to enhance the software development workflow by making it context-aware. Each step in the workflow is interactive through a user-friendly interface, incorporating the entire software development lifecycle into each stage.
+
+## Architecture
+
+Autobyteus is built with a modular, event-driven architecture designed for extensibility and clear separation of concerns. The key components are:
+
+-   **Agent Core**: The heart of the system, comprising an `Agent` facade that provides the primary user-facing API. This facade communicates with an `AgentRuntime`, which manages an `AgentWorker` running in a dedicated thread. This design ensures non-blocking agent operations.
+-   **Context & Configuration**: Agent behavior is defined through a clear configuration (`AgentConfig`) and its dynamic state is managed in `AgentRuntimeState`. These are bundled into a comprehensive `AgentContext` that is available to all components during runtime, providing a single source of truth for an agent's status and capabilities.
+-   **Event-Driven System**: Agents operate on an internal event loop. Actions (like receiving user messages or tool results) are translated into events and placed on internal queues. `EventHandlers` process these events, containing the core logic for how an agent thinks and acts. This decouples logic and makes the system easy to extend.
+-   **Pluggable Processors**: The framework uses a pipeline of processors to modify data at key stages. `SystemPromptProcessors` dynamically build the final system prompt (e.g., by injecting tool definitions), `InputProcessors` preprocess user messages, and `LLMResponseProcessors` parse outputs from the language model (e.g., to detect tool usage).
+-   **Tooling**: Agents can be extended with `Tools`, which are self-contained capabilities that can be called by the LLM. The system includes built-in tools (like `SendMessageTo` for inter-agent communication) and supports custom tools.
+-   **Multi-Agent Systems**: The `AgentGroup` and `AgenticWorkflow` abstractions provide powerful, high-level APIs for orchestrating multiple agents to collaborate on complex tasks.
+-   **Remote Agents**: Built-in RPC capabilities allow for communication with agents running in separate processes or on different machines, enabling distributed agent systems.
+
+## Features
+
+- **Context-Aware Workflows**: Each step in the development process interacts with large language models to provide relevant assistance.
+- **Lifecycle Integration**: Supports the entire software development lifecycle, starting from requirement engineering.
+- **Memory Management**: Custom memory management system supporting different memory providers and embeddings.
+
+## Knowledge Base
+
+A significant part of Autobyteus is our custom-designed knowledge base focused on software and application development. The knowledge base is structured to support the entire development process, with particular emphasis on requirement engineering, which is crucial for successful project outcomes.
+
+## Requirements
+
+-   **Python Version**: Python 3.11 is the recommended and tested version for this project. Using newer versions of Python may result in dependency conflicts when installing the required packages. For a stable and tested environment, please use Python 3.11.
+
+## Getting Started
+
+### Installation
+
+1. **For users:**
+   To install Autobyteus, run:
+   ```
+   pip install .
+   ```
+
+2. **For developers:**
+   To install Autobyteus with development dependencies, run:
+   ```
+   pip install -r requirements-dev.txt
+   ```
+
+3. **Platform-specific dependencies:**
+   To install platform-specific dependencies, run:
+   ```
+   python setup.py install_platform_deps
+   ```
+
+### Building the Library
+
+To build Autobyteus as a distributable package, follow these steps:
+
+1. Ensure you have the latest version of `setuptools` and `wheel` installed:
+   ```
+   pip install --upgrade setuptools wheel
+   ```
+
+2. Build the distribution packages:
+   ```
+   python setup.py sdist bdist_wheel
+   ```
+
+   This will create a `dist` directory containing the built distributions.
+
+3. (Optional) To create a source distribution only:
+   ```
+   python setup.py sdist
+   ```
+
+4. (Optional) To create a wheel distribution only:
+   ```
+   python setup.py bdist_wheel
+   ```
+
+The built packages will be in the `dist` directory and can be installed using pip or distributed as needed.
+
+### Usage
+
+(Add basic commands and examples to get users started)
+
+### Contributing
+
+(Add guidelines for contributing to the project)
+
+## License
+
+This project is licensed under the MIT License.

autobyteus-1.1.0/autobyteus/agent/agent.py

@@ -0,0 +1,106 @@
+# file: autobyteus/autobyteus/agent/agent.py
+import asyncio
+import logging
+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:
+    """
+    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)
+
+
+    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__}."
+            )
+        
+        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
+            
+        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-1.1.0/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-1.1.0/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.context.agent_phase_manager 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-1.1.0/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.context.agent_phase_manager 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-1.1.0/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.context.agent_phase_manager 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-1.1.0/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.context.agent_phase_manager 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

autobyteus-1.1.0/autobyteus/agent/bootstrap_steps/workspace_context_initialization_step.py

@@ -0,0 +1,47 @@
+# file: autobyteus/autobyteus/agent/bootstrap_steps/workspace_context_initialization_step.py
+import logging
+from typing import TYPE_CHECKING
+
+from .base_bootstrap_step import BaseBootstrapStep
+
+if TYPE_CHECKING:
+    from autobyteus.agent.context import AgentContext
+    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
+
+logger = logging.getLogger(__name__)
+
+class WorkspaceContextInitializationStep(BaseBootstrapStep):
+    """
+    Bootstrap step for injecting the AgentContext into the agent's workspace instance.
+    """
+
+    def __init__(self):
+        logger.debug("WorkspaceContextInitializationStep initialized.")
+
+    async def execute(self,
+                      context: 'AgentContext',
+                      phase_manager: 'AgentPhaseManager') -> bool:
+        agent_id = context.agent_id
+        logger.info(f"Agent '{agent_id}': Executing WorkspaceContextInitializationStep.")
+
+        workspace = context.workspace
+
+        if not workspace:
+            logger.debug(f"Agent '{agent_id}': No workspace configured. Skipping context injection.")
+            return True
+
+        try:
+            if hasattr(workspace, 'set_context') and callable(getattr(workspace, 'set_context')):
+                workspace.set_context(context)
+                logger.info(f"Agent '{agent_id}': AgentContext successfully injected into workspace instance of type '{type(workspace).__name__}'.")
+            else:
+                logger.warning(f"Agent '{agent_id}': Configured workspace of type '{type(workspace).__name__}' does not have a 'set_context' method. "
+                               "Workspace will not have access to the agent's context.")
+
+            return True
+        except Exception as e:
+            error_message = f"Agent '{agent_id}': Critical failure during WorkspaceContextInitializationStep: {e}"
+            logger.error(error_message, exc_info=True)
+            # No easy way to enqueue an error event here if queues aren't even initialized yet.
+            # The failure of a bootstrap step is handled by the bootstrapper, which will log and set error phase.
+            return False

autobyteus-1.1.0/autobyteus/agent/context/__init__.py

@@ -0,0 +1,18 @@
+# file: autobyteus/autobyteus/agent/context/__init__.py
+"""
+Components related to the agent's runtime context, state, config, and status management.
+"""
+from .agent_config import AgentConfig
+from .agent_runtime_state import AgentRuntimeState
+from .agent_context import AgentContext 
+from .agent_phase_manager import AgentPhaseManager
+from .phases import AgentOperationalPhase
+
+
+__all__ = [
+    "AgentContext",
+    "AgentConfig", 
+    "AgentRuntimeState", 
+    "AgentPhaseManager",
+    "AgentOperationalPhase",
+]