autobyteus 1.0.6__tar.gz → 1.1.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.0.6
+Version: 1.1.1
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -25,10 +25,12 @@ Requires-Dist: boto3
 Requires-Dist: botocore
 Requires-Dist: anthropic==0.37.1
 Requires-Dist: Jinja2
-Requires-Dist: ollama==0.4.5
+Requires-Dist: ollama
 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: autobyteus-llm-client==1.1.1
 Requires-Dist: brui-core==1.0.8
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
@@ -64,7 +66,19 @@ Dynamic: summary
 
 # 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.
+Autobyteus is an open-source, application-first agentic framework for Python. It is designed to help developers build, test, and deploy complex, stateful, and extensible AI agents by providing a robust architecture and a powerful set of tools.
+
+## 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. Each agent is a stateful, autonomous entity that runs as a background process in its own thread, managed by a dedicated `AgentWorker`. This design makes every agent a truly independent entity capable of handling long-running tasks.
+-   **Context & Configuration**: Agent behavior is defined through a static configuration (`AgentConfig`) and its dynamic state is managed in `AgentRuntimeState`. These are bundled into a comprehensive `AgentContext` that is passed to all components, providing a single source of truth.
+-   **Event-Driven System**: Agents operate on an internal `asyncio` event loop. User messages, tool results, and internal signals are handled as events, which are processed by dedicated `EventHandlers`. This decouples logic and makes the system highly extensible.
+-   **Pluggable Processors & Hooks**: The framework provides extension points to inject custom logic. `InputProcessors` and `LLMResponseProcessors` modify data in the main processing pipeline, while `PhaseHooks` allow custom code to run on specific agent lifecycle transitions (e.g., from `BOOTSTRAPPING` to `IDLE`).
+-   **Context-Aware Tooling**: Tools are first-class citizens that receive the agent's full `AgentContext` during execution. This allows tools to be deeply integrated with the agent's state, configuration, and workspace, enabling more intelligent and powerful actions.
+-   **Tool Approval Flow**: The framework has native support for human-in-the-loop workflows. By setting `auto_execute_tools=False` in the agent's configuration, the agent will pause before executing a tool, emit an event requesting permission, and wait for external approval before proceeding.
+-   **MCP Integration**: The framework has native support for the Model Context Protocol (MCP). This allows agents to discover and use tools from external, language-agnostic tool servers, making the ecosystem extremely flexible and ready for enterprise integration.
 
 ## Features
 
@@ -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.1/README.md

@@ -0,0 +1,91 @@
+# Autobyteus
+
+Autobyteus is an open-source, application-first agentic framework for Python. It is designed to help developers build, test, and deploy complex, stateful, and extensible AI agents by providing a robust architecture and a powerful set of tools.
+
+## 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. Each agent is a stateful, autonomous entity that runs as a background process in its own thread, managed by a dedicated `AgentWorker`. This design makes every agent a truly independent entity capable of handling long-running tasks.
+-   **Context & Configuration**: Agent behavior is defined through a static configuration (`AgentConfig`) and its dynamic state is managed in `AgentRuntimeState`. These are bundled into a comprehensive `AgentContext` that is passed to all components, providing a single source of truth.
+-   **Event-Driven System**: Agents operate on an internal `asyncio` event loop. User messages, tool results, and internal signals are handled as events, which are processed by dedicated `EventHandlers`. This decouples logic and makes the system highly extensible.
+-   **Pluggable Processors & Hooks**: The framework provides extension points to inject custom logic. `InputProcessors` and `LLMResponseProcessors` modify data in the main processing pipeline, while `PhaseHooks` allow custom code to run on specific agent lifecycle transitions (e.g., from `BOOTSTRAPPING` to `IDLE`).
+-   **Context-Aware Tooling**: Tools are first-class citizens that receive the agent's full `AgentContext` during execution. This allows tools to be deeply integrated with the agent's state, configuration, and workspace, enabling more intelligent and powerful actions.
+-   **Tool Approval Flow**: The framework has native support for human-in-the-loop workflows. By setting `auto_execute_tools=False` in the agent's configuration, the agent will pause before executing a tool, emit an event requesting permission, and wait for external approval before proceeding.
+-   **MCP Integration**: The framework has native support for the Model Context Protocol (MCP). This allows agents to discover and use tools from external, language-agnostic tool servers, making the ecosystem extremely flexible and ready for enterprise integration.
+
+## 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.1/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.1/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.1/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-1.1.1/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-1.1.1/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-1.1.1/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

autobyteus-1.1.1/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.phases 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.1/autobyteus/agent/context/__init__.py

@@ -0,0 +1,13 @@
+# 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 
+
+__all__ = [
+    "AgentContext",
+    "AgentConfig", 
+    "AgentRuntimeState", 
+]