autobyteus 1.1.0__tar.gz → 1.1.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: autobyteus
-Version: 1.1.0
+Version: 1.1.1
 Summary: Multi-Agent framework
 Home-page: https://github.com/AutoByteus/autobyteus
 Author: Ryan Zheng
@@ -25,12 +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"
@@ -66,19 +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, 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.
+-   **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
 

{autobyteus-1.1.0 → autobyteus-1.1.1}/README.md

@@ -1,18 +1,18 @@
 # 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, 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.
+-   **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
 

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/bootstrap_steps/agent_bootstrapper.py

@@ -10,7 +10,7 @@ from autobyteus.agent.events import AgentReadyEvent
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
+    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/bootstrap_steps/agent_runtime_queue_initialization_step.py

@@ -8,7 +8,7 @@ from autobyteus.agent.events import AgentErrorEvent, AgentInputEventQueueManager
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
+    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/bootstrap_steps/base_bootstrap_step.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
+    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/bootstrap_steps/system_prompt_processing_step.py

@@ -8,7 +8,7 @@ from autobyteus.agent.system_prompt_processor.base_processor import BaseSystemPr
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
+    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/bootstrap_steps/workspace_context_initialization_step.py

@@ -6,7 +6,7 @@ from .base_bootstrap_step import BaseBootstrapStep
 
 if TYPE_CHECKING:
     from autobyteus.agent.context import AgentContext
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager
+    from autobyteus.agent.phases import AgentPhaseManager
 
 logger = logging.getLogger(__name__)
 

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/context/__init__.py

@@ -5,14 +5,9 @@ Components related to the agent's runtime context, state, config, and status man
 from .agent_config import AgentConfig
 from .agent_runtime_state import AgentRuntimeState
 from .agent_context import AgentContext 
-from .agent_phase_manager import AgentPhaseManager
-from .phases import AgentOperationalPhase
-
 
 __all__ = [
     "AgentContext",
     "AgentConfig", 
     "AgentRuntimeState", 
-    "AgentPhaseManager",
-    "AgentOperationalPhase",
 ]

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/context/agent_config.py

@@ -1,6 +1,6 @@
 # file: autobyteus/autobyteus/agent/context/agent_config.py
 import logging
-from typing import List, Optional, Union, Tuple, TYPE_CHECKING
+from typing import List, Optional, Union, Tuple, TYPE_CHECKING, Dict, Any
 
 # Correctly import the new master processor and the base class
 from autobyteus.agent.system_prompt_processor import ToolManifestInjectorProcessor, BaseSystemPromptProcessor
@@ -40,7 +40,8 @@ class AgentConfig:
                  llm_response_processors: Optional[List['BaseLLMResponseProcessor']] = None,
                  system_prompt_processors: Optional[List['BaseSystemPromptProcessor']] = None,
                  workspace: Optional['BaseAgentWorkspace'] = None,
-                 phase_hooks: Optional[List['BasePhaseHook']] = None):
+                 phase_hooks: Optional[List['BasePhaseHook']] = None,
+                 initial_custom_data: Optional[Dict[str, Any]] = None):
         """
         Initializes the AgentConfig.
 
@@ -59,6 +60,8 @@ class AgentConfig:
             system_prompt_processors: A list of system prompt processor instances.
             workspace: An optional pre-initialized workspace instance for the agent.
             phase_hooks: An optional list of phase transition hook instances.
+            initial_custom_data: An optional dictionary of data to pre-populate
+                                 the agent's runtime state `custom_data`.
         """
         self.name = name
         self.role = role
@@ -73,6 +76,7 @@ class AgentConfig:
         self.llm_response_processors = llm_response_processors if llm_response_processors is not None else list(self.DEFAULT_LLM_RESPONSE_PROCESSORS)
         self.system_prompt_processors = system_prompt_processors if system_prompt_processors is not None else list(self.DEFAULT_SYSTEM_PROMPT_PROCESSORS)
         self.phase_hooks = phase_hooks or []
+        self.initial_custom_data = initial_custom_data
 
         logger.debug(f"AgentConfig created for name '{self.name}', role '{self.role}'.")
 

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/context/agent_context.py

@@ -2,7 +2,7 @@
 import logging
 from typing import TYPE_CHECKING, List, Dict, Any, Optional
 
-from .phases import AgentOperationalPhase 
+from autobyteus.agent.phases import AgentOperationalPhase 
 
 if TYPE_CHECKING:
     from .agent_config import AgentConfig 
@@ -13,7 +13,7 @@ if TYPE_CHECKING:
     from autobyteus.agent.tool_invocation import ToolInvocation
     # LLMConfig no longer needed here
     from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager 
+    from autobyteus.agent.phases import AgentPhaseManager 
 
 logger = logging.getLogger(__name__)
 
@@ -48,9 +48,6 @@ class AgentContext:
     @property
     def auto_execute_tools(self) -> bool:
         return self.config.auto_execute_tools
-    
-    # llm_model_name property removed
-    # custom_llm_config property removed
 
     @property
     def llm_instance(self) -> Optional['BaseLLM']:

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/context/agent_phase_manager.py

@@ -3,7 +3,7 @@ import asyncio
 import logging
 from typing import TYPE_CHECKING, Optional, Dict, Any
 
-from .phases import AgentOperationalPhase
+from autobyteus.agent.phases import AgentOperationalPhase, phase_transition
 
 if TYPE_CHECKING:
     from autobyteus.agent.context.agent_context import AgentContext
@@ -84,6 +84,11 @@ class AgentPhaseManager:
         else: 
             logger.error(f"AgentPhaseManager for '{self.context.agent_id}': Notifier method '{notify_method_name}' not found or not callable on {type(self.notifier).__name__}.")
 
+    @phase_transition(
+        source_phases=[AgentOperationalPhase.SHUTDOWN_COMPLETE, AgentOperationalPhase.ERROR],
+        target_phase=AgentOperationalPhase.UNINITIALIZED,
+        description="Triggered when the agent runtime is started or restarted after being in a terminal state."
+    )
     async def notify_runtime_starting_and_uninitialized(self) -> None:
         if self.context.current_phase == AgentOperationalPhase.UNINITIALIZED:
             await self._transition_phase(AgentOperationalPhase.UNINITIALIZED, "notify_phase_uninitialized_entered")
@@ -92,9 +97,19 @@ class AgentPhaseManager:
         else:
              logger.warning(f"Agent '{self.context.agent_id}' notify_runtime_starting_and_uninitialized called in unexpected phase: {self.context.current_phase.value}")
 
+    @phase_transition(
+        source_phases=[AgentOperationalPhase.UNINITIALIZED],
+        target_phase=AgentOperationalPhase.BOOTSTRAPPING,
+        description="Occurs when the agent's internal bootstrapping process begins."
+    )
     async def notify_bootstrapping_started(self) -> None:
         await self._transition_phase(AgentOperationalPhase.BOOTSTRAPPING, "notify_phase_bootstrapping_started")
 
+    @phase_transition(
+        source_phases=[AgentOperationalPhase.BOOTSTRAPPING],
+        target_phase=AgentOperationalPhase.IDLE,
+        description="Occurs when the agent successfully completes bootstrapping and is ready for input."
+    )
     async def notify_initialization_complete(self) -> None:
         if self.context.current_phase.is_initializing() or self.context.current_phase == AgentOperationalPhase.UNINITIALIZED:
             # This will now be a BOOTSTRAPPING -> IDLE transition
@@ -102,8 +117,17 @@ class AgentPhaseManager:
         else:
             logger.warning(f"Agent '{self.context.agent_id}' notify_initialization_complete called in unexpected phase: {self.context.current_phase.value}")
 
+    @phase_transition(
+        source_phases=[
+            AgentOperationalPhase.IDLE, AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
+            AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.EXECUTING_TOOL,
+            AgentOperationalPhase.TOOL_DENIED
+        ],
+        target_phase=AgentOperationalPhase.PROCESSING_USER_INPUT,
+        description="Fires when the agent begins processing a new user message or inter-agent message."
+    )
     async def notify_processing_input_started(self, trigger_info: Optional[str] = None) -> None:
-        if self.context.current_phase in [AgentOperationalPhase.IDLE, AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.EXECUTING_TOOL]:
+        if self.context.current_phase in [AgentOperationalPhase.IDLE, AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.EXECUTING_TOOL, AgentOperationalPhase.TOOL_DENIED]:
             data = {"trigger_info": trigger_info} if trigger_info else {}
             await self._transition_phase(AgentOperationalPhase.PROCESSING_USER_INPUT, "notify_phase_processing_user_input_started", additional_data=data)
         elif self.context.current_phase == AgentOperationalPhase.PROCESSING_USER_INPUT:
@@ -111,30 +135,79 @@ class AgentPhaseManager:
         else:
              logger.warning(f"Agent '{self.context.agent_id}' notify_processing_input_started called in unexpected phase: {self.context.current_phase.value}")
 
+    @phase_transition(
+        source_phases=[AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.PROCESSING_TOOL_RESULT],
+        target_phase=AgentOperationalPhase.AWAITING_LLM_RESPONSE,
+        description="Occurs just before the agent makes a call to the LLM."
+    )
     async def notify_awaiting_llm_response(self) -> None:
         await self._transition_phase(AgentOperationalPhase.AWAITING_LLM_RESPONSE, "notify_phase_awaiting_llm_response_started")
 
+    @phase_transition(
+        source_phases=[AgentOperationalPhase.AWAITING_LLM_RESPONSE],
+        target_phase=AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
+        description="Occurs after the agent has received a complete response from the LLM and begins to analyze it."
+    )
     async def notify_analyzing_llm_response(self) -> None:
         await self._transition_phase(AgentOperationalPhase.ANALYZING_LLM_RESPONSE, "notify_phase_analyzing_llm_response_started")
 
+    @phase_transition(
+        source_phases=[AgentOperationalPhase.ANALYZING_LLM_RESPONSE],
+        target_phase=AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
+        description="Occurs if the agent proposes a tool use that requires manual user approval."
+    )
     async def notify_tool_execution_pending_approval(self, tool_invocation: 'ToolInvocation') -> None:
-        # The notifier's notify_phase_awaiting_tool_approval_started method no longer takes tool_details.
-        # The phase event itself is the signal. Tool data comes via queue.
         await self._transition_phase(AgentOperationalPhase.AWAITING_TOOL_APPROVAL, "notify_phase_awaiting_tool_approval_started")
 
+    @phase_transition(
+        source_phases=[AgentOperationalPhase.AWAITING_TOOL_APPROVAL],
+        target_phase=AgentOperationalPhase.EXECUTING_TOOL,
+        description="Occurs after a pending tool use has been approved and is about to be executed."
+    )
     async def notify_tool_execution_resumed_after_approval(self, approved: bool, tool_name: Optional[str]) -> None:
         if approved and tool_name:
             await self._transition_phase(AgentOperationalPhase.EXECUTING_TOOL, "notify_phase_executing_tool_started", additional_data={"tool_name": tool_name})
         else:
             logger.info(f"Agent '{self.context.agent_id}' tool execution denied for '{tool_name}'. Transitioning to allow LLM to process denial.")
-            await self._transition_phase(AgentOperationalPhase.ANALYZING_LLM_RESPONSE, "notify_phase_analyzing_llm_response_started", additional_data={"denial_for_tool": tool_name})
+            await self.notify_tool_denied(tool_name)
 
+    @phase_transition(
+        source_phases=[AgentOperationalPhase.AWAITING_TOOL_APPROVAL],
+        target_phase=AgentOperationalPhase.TOOL_DENIED,
+        description="Occurs after a pending tool use has been denied by the user."
+    )
+    async def notify_tool_denied(self, tool_name: Optional[str]) -> None:
+        """Notifies that a tool execution has been denied."""
+        await self._transition_phase(
+            AgentOperationalPhase.TOOL_DENIED,
+            "notify_phase_tool_denied_started",
+            additional_data={"tool_name": tool_name, "denial_for_tool": tool_name}
+        )
+
+    @phase_transition(
+        source_phases=[AgentOperationalPhase.ANALYZING_LLM_RESPONSE],
+        target_phase=AgentOperationalPhase.EXECUTING_TOOL,
+        description="Occurs when an agent with auto-approval executes a tool."
+    )
     async def notify_tool_execution_started(self, tool_name: str) -> None:
         await self._transition_phase(AgentOperationalPhase.EXECUTING_TOOL, "notify_phase_executing_tool_started", additional_data={"tool_name": tool_name})
 
+    @phase_transition(
+        source_phases=[AgentOperationalPhase.EXECUTING_TOOL],
+        target_phase=AgentOperationalPhase.PROCESSING_TOOL_RESULT,
+        description="Fires after a tool has finished executing and the agent begins processing its result."
+    )
     async def notify_processing_tool_result(self, tool_name: str) -> None:
         await self._transition_phase(AgentOperationalPhase.PROCESSING_TOOL_RESULT, "notify_phase_processing_tool_result_started", additional_data={"tool_name": tool_name})
 
+    @phase_transition(
+        source_phases=[
+            AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
+            AgentOperationalPhase.PROCESSING_TOOL_RESULT
+        ],
+        target_phase=AgentOperationalPhase.IDLE,
+        description="Occurs when an agent completes a processing cycle and is waiting for new input."
+    )
     async def notify_processing_complete_and_idle(self) -> None:
         if not self.context.current_phase.is_terminal() and self.context.current_phase != AgentOperationalPhase.IDLE:
             await self._transition_phase(AgentOperationalPhase.IDLE, "notify_phase_idle_entered")
@@ -143,6 +216,17 @@ class AgentPhaseManager:
         else:
             logger.warning(f"Agent '{self.context.agent_id}' notify_processing_complete_and_idle called in unexpected phase: {self.context.current_phase.value}")
 
+    @phase_transition(
+        source_phases=[
+            AgentOperationalPhase.UNINITIALIZED, AgentOperationalPhase.BOOTSTRAPPING, AgentOperationalPhase.IDLE,
+            AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.AWAITING_LLM_RESPONSE,
+            AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
+            AgentOperationalPhase.TOOL_DENIED, AgentOperationalPhase.EXECUTING_TOOL,
+            AgentOperationalPhase.PROCESSING_TOOL_RESULT, AgentOperationalPhase.SHUTTING_DOWN
+        ],
+        target_phase=AgentOperationalPhase.ERROR,
+        description="A catch-all transition that can occur from any non-terminal state if an unrecoverable error happens."
+    )
     async def notify_error_occurred(self, error_message: str, error_details: Optional[str] = None) -> None:
         if self.context.current_phase != AgentOperationalPhase.ERROR:
             data = {"error_message": error_message, "error_details": error_details}
@@ -150,12 +234,28 @@ class AgentPhaseManager:
         else:
             logger.debug(f"Agent '{self.context.agent_id}' already in ERROR phase when another error notified: {error_message}")
 
+    @phase_transition(
+        source_phases=[
+            AgentOperationalPhase.UNINITIALIZED, AgentOperationalPhase.BOOTSTRAPPING, AgentOperationalPhase.IDLE,
+            AgentOperationalPhase.PROCESSING_USER_INPUT, AgentOperationalPhase.AWAITING_LLM_RESPONSE,
+            AgentOperationalPhase.ANALYZING_LLM_RESPONSE, AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
+            AgentOperationalPhase.TOOL_DENIED, AgentOperationalPhase.EXECUTING_TOOL,
+            AgentOperationalPhase.PROCESSING_TOOL_RESULT
+        ],
+        target_phase=AgentOperationalPhase.SHUTTING_DOWN,
+        description="Fires when the agent begins its graceful shutdown sequence."
+    )
     async def notify_shutdown_initiated(self) -> None:
         if not self.context.current_phase.is_terminal():
              await self._transition_phase(AgentOperationalPhase.SHUTTING_DOWN, "notify_phase_shutting_down_started")
         else:
             logger.debug(f"Agent '{self.context.agent_id}' shutdown initiated but already in a terminal phase: {self.context.current_phase.value}")
 
+    @phase_transition(
+        source_phases=[AgentOperationalPhase.SHUTTING_DOWN],
+        target_phase=AgentOperationalPhase.SHUTDOWN_COMPLETE,
+        description="The final transition when the agent has successfully shut down and released its resources."
+    )
     async def notify_final_shutdown_complete(self) -> None:
         final_phase = AgentOperationalPhase.ERROR if self.context.current_phase == AgentOperationalPhase.ERROR else AgentOperationalPhase.SHUTDOWN_COMPLETE
         if final_phase == AgentOperationalPhase.ERROR:

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/context/agent_runtime_state.py

@@ -7,14 +7,14 @@ from autobyteus.agent.events.agent_input_event_queue_manager import AgentInputEv
 # from autobyteus.agent.events.agent_output_data_manager import AgentOutputDataManager       
 
 from autobyteus.llm.base_llm import BaseLLM
-from .phases import AgentOperationalPhase 
+from autobyteus.agent.phases import AgentOperationalPhase 
 from autobyteus.agent.workspace.base_workspace import BaseAgentWorkspace
 from autobyteus.agent.tool_invocation import ToolInvocation
 # LLMConfig is no longer needed here
 # from autobyteus.llm.utils.llm_config import LLMConfig 
 
 if TYPE_CHECKING:
-    from autobyteus.agent.context.agent_phase_manager import AgentPhaseManager 
+    from autobyteus.agent.phases import AgentPhaseManager 
     from autobyteus.tools.base_tool import BaseTool 
 
 logger = logging.getLogger(__name__)

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/context/phases.py

@@ -15,6 +15,7 @@ class AgentOperationalPhase(str, Enum):
     ANALYZING_LLM_RESPONSE = "analyzing_llm_response"   # Received LLM response, analyzing it for next actions (e.g., tool use, direct reply).
     
     AWAITING_TOOL_APPROVAL = "awaiting_tool_approval"   # Paused, needs external (user) approval for a tool invocation.
+    TOOL_DENIED = "tool_denied"                         # A proposed tool execution was denied by the user. Agent is processing the denial.
     EXECUTING_TOOL = "executing_tool"                   # Tool has been approved (or auto-approved) and is currently running.
     PROCESSING_TOOL_RESULT = "processing_tool_result"   # Received a tool's result, actively processing it (often leading to another LLM call).
     
@@ -38,6 +39,7 @@ class AgentOperationalPhase(str, Enum):
             AgentOperationalPhase.AWAITING_LLM_RESPONSE,
             AgentOperationalPhase.ANALYZING_LLM_RESPONSE,
             AgentOperationalPhase.AWAITING_TOOL_APPROVAL,
+            AgentOperationalPhase.TOOL_DENIED,
             AgentOperationalPhase.EXECUTING_TOOL,
             AgentOperationalPhase.PROCESSING_TOOL_RESULT,
         ]

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/events/__init__.py

@@ -12,17 +12,11 @@ from .agent_events import (
     LifecycleEvent,
     AgentProcessingEvent,
     # Agent Phase-Specific Base Events
-    AgentPreparationEvent, 
     AgentOperationalEvent,
     # Specific Lifecycle Events
     AgentReadyEvent, 
     AgentStoppedEvent,
     AgentErrorEvent,
-    # DEPRECATED Initialization Events
-    CreateToolInstancesEvent, 
-    ProcessSystemPromptEvent,
-    FinalizeLLMConfigEvent,
-    CreateLLMInstanceEvent,
     # Regular Agent Processing Events
     UserMessageReceivedEvent, 
     InterAgentMessageReceivedEvent, 
@@ -42,15 +36,10 @@ __all__ = [
     "BaseEvent",
     "LifecycleEvent",
     "AgentProcessingEvent",
-    "AgentPreparationEvent", 
     "AgentOperationalEvent", 
     "AgentReadyEvent", 
     "AgentStoppedEvent",
     "AgentErrorEvent",
-    "CreateToolInstancesEvent", 
-    "ProcessSystemPromptEvent", 
-    "FinalizeLLMConfigEvent",   
-    "CreateLLMInstanceEvent",   
     "UserMessageReceivedEvent",
     "InterAgentMessageReceivedEvent",
     "LLMUserMessageReadyEvent", 

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/events/agent_events.py

@@ -25,43 +25,6 @@ class AgentProcessingEvent(BaseEvent):
     """Base class for events related to the agent's internal data processing and task execution logic."""
 
 
-# --- Agent Initialization Sequence Events ---
-@dataclass
-class AgentPreparationEvent(AgentProcessingEvent):
-    """Base class for events that are part of the agent's preparation/initialization sequence."""
-    pass
-
-# BootstrapAgentEvent REMOVED
-
-@dataclass
-class CreateToolInstancesEvent(AgentPreparationEvent): 
-    """
-    DEPRECATED. Initialization is now handled directly by the agent worker.
-    """
-    pass
-
-@dataclass
-class ProcessSystemPromptEvent(AgentPreparationEvent):
-    """
-    DEPRECATED. Initialization is now handled directly by the agent worker.
-    """
-    pass
-
-@dataclass
-class FinalizeLLMConfigEvent(AgentPreparationEvent):
-    """
-    DEPRECATED. Initialization is now handled directly by the agent worker.
-    """
-    pass
-
-@dataclass
-class CreateLLMInstanceEvent(AgentPreparationEvent):
-    """
-    DEPRECATED. Initialization is now handled directly by the agent worker.
-    """
-    pass
-
-
 # --- Agent Operational Phase Events ---
 @dataclass
 class AgentOperationalEvent(AgentProcessingEvent): 

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/events/notifiers.py

@@ -4,7 +4,7 @@ from typing import Optional, Dict, Any, TYPE_CHECKING
 
 from autobyteus.events.event_emitter import EventEmitter
 from autobyteus.events.event_types import EventType 
-from autobyteus.agent.context.phases import AgentOperationalPhase
+from autobyteus.agent.phases import AgentOperationalPhase
 
 if TYPE_CHECKING:
     from autobyteus.llm.utils.response_types import ChunkResponse, CompleteResponse 
@@ -27,7 +27,15 @@ class AgentExternalEventNotifier(EventEmitter):
             emit_kwargs["payload"] = payload_content 
         
         self.emit(event_type, **emit_kwargs) 
-        logger.info(f"AgentExternalEventNotifier (NotifierID: {self.object_id}, AgentID: {self.agent_id}) emitted {event_type.name}. Kwarg keys for emit: {list(emit_kwargs.keys())}")
+        log_message = (
+            f"AgentExternalEventNotifier (NotifierID: {self.object_id}, AgentID: {self.agent_id}) "
+            f"emitted {event_type.name}. Kwarg keys for emit: {list(emit_kwargs.keys())}"
+        )
+        # Reduce log level for high-frequency events like streaming chunks
+        if event_type == EventType.AGENT_DATA_ASSISTANT_CHUNK:
+            logger.debug(log_message)
+        else:
+            logger.info(log_message)
 
 
     def _emit_phase_change(self, 
@@ -57,10 +65,18 @@ class AgentExternalEventNotifier(EventEmitter):
         self._emit_phase_change(EventType.AGENT_PHASE_PROCESSING_USER_INPUT_STARTED, AgentOperationalPhase.PROCESSING_USER_INPUT, old_phase, additional_data=data)
     def notify_phase_awaiting_llm_response_started(self, old_phase: Optional[AgentOperationalPhase]):
         self._emit_phase_change(EventType.AGENT_PHASE_AWAITING_LLM_RESPONSE_STARTED, AgentOperationalPhase.AWAITING_LLM_RESPONSE, old_phase)
+
     def notify_phase_analyzing_llm_response_started(self, old_phase: Optional[AgentOperationalPhase]):
         self._emit_phase_change(EventType.AGENT_PHASE_ANALYZING_LLM_RESPONSE_STARTED, AgentOperationalPhase.ANALYZING_LLM_RESPONSE, old_phase)
+
     def notify_phase_awaiting_tool_approval_started(self, old_phase: Optional[AgentOperationalPhase]):
         self._emit_phase_change(EventType.AGENT_PHASE_AWAITING_TOOL_APPROVAL_STARTED, AgentOperationalPhase.AWAITING_TOOL_APPROVAL, old_phase)
+
+    def notify_phase_tool_denied_started(self, old_phase: Optional[AgentOperationalPhase], tool_name: Optional[str], denial_for_tool: Optional[str]):
+        data = {"tool_name": tool_name, "denial_for_tool": denial_for_tool}
+        # Assuming EventType.AGENT_PHASE_TOOL_DENIED_STARTED exists in the main EventType enum
+        self._emit_phase_change(EventType.AGENT_PHASE_TOOL_DENIED_STARTED, AgentOperationalPhase.TOOL_DENIED, old_phase, additional_data=data)
+
     def notify_phase_executing_tool_started(self, old_phase: Optional[AgentOperationalPhase], tool_name: str):
         data = {"tool_name": tool_name}
         self._emit_phase_change(EventType.AGENT_PHASE_EXECUTING_TOOL_STARTED, AgentOperationalPhase.EXECUTING_TOOL, old_phase, additional_data=data)
@@ -81,13 +97,11 @@ class AgentExternalEventNotifier(EventEmitter):
     def notify_agent_data_assistant_chunk_stream_end(self): 
         self._emit_event(EventType.AGENT_DATA_ASSISTANT_CHUNK_STREAM_END) 
 
-    # RENAMED METHOD
-    def notify_agent_data_assistant_complete_response(self, complete_response: 'CompleteResponse'): # RENAMED from notify_agent_data_assistant_final_message
-        # Use RENAMED EventType
+    def notify_agent_data_assistant_complete_response(self, complete_response: 'CompleteResponse'):
         self._emit_event(EventType.AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE, payload_content=complete_response) 
 
-    def notify_agent_data_tool_log(self, log_entry: str): 
-        self._emit_event(EventType.AGENT_DATA_TOOL_LOG, payload_content=log_entry) 
+    def notify_agent_data_tool_log(self, log_data: Dict[str, Any]): 
+        self._emit_event(EventType.AGENT_DATA_TOOL_LOG, payload_content=log_data) 
     
     def notify_agent_data_tool_log_stream_end(self): 
         self._emit_event(EventType.AGENT_DATA_TOOL_LOG_STREAM_END) 
@@ -95,6 +109,10 @@ class AgentExternalEventNotifier(EventEmitter):
     def notify_agent_request_tool_invocation_approval(self, approval_data: Dict[str, Any]): 
         self._emit_event(EventType.AGENT_REQUEST_TOOL_INVOCATION_APPROVAL, payload_content=approval_data) 
 
+    def notify_agent_tool_invocation_auto_executing(self, auto_exec_data: Dict[str, Any]):
+        """Notifies that a tool is being automatically executed."""
+        self._emit_event(EventType.AGENT_TOOL_INVOCATION_AUTO_EXECUTING, payload_content=auto_exec_data)
+
     def notify_agent_error_output_generation(self, error_source: str, error_message: str, error_details: Optional[str] = None): 
         payload_dict = { 
             "source": error_source,

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/events/worker_event_dispatcher.py

@@ -4,7 +4,7 @@ import logging
 import traceback
 from typing import TYPE_CHECKING, Optional
 
-from autobyteus.agent.context.phases import AgentOperationalPhase
+from autobyteus.agent.phases import AgentOperationalPhase
 from autobyteus.agent.events.agent_events import ( # Updated relative import path if needed, but BaseEvent is fine
     BaseEvent,
     AgentReadyEvent,

{autobyteus-1.1.0 → autobyteus-1.1.1}/autobyteus/agent/factory/agent_factory.py

@@ -75,8 +75,12 @@ class AgentFactory(metaclass=SingletonMeta):
                         ) -> 'AgentRuntime': 
         from autobyteus.agent.runtime.agent_runtime import AgentRuntime 
 
-        # The workspace is now passed directly from the config
-        runtime_state = AgentRuntimeState(agent_id=agent_id, workspace=config.workspace)
+        # The workspace and initial custom data are now passed directly from the config to the state.
+        runtime_state = AgentRuntimeState(
+            agent_id=agent_id,
+            workspace=config.workspace,
+            custom_data=config.initial_custom_data
+        )
         
         # --- Set pre-initialized instances on the state ---
         runtime_state.llm_instance = config.llm_instance