autobyteus 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

autobyteus/agent/runtime/agent_worker.py

@@ -6,7 +6,7 @@ import threading
 import concurrent.futures
 from typing import TYPE_CHECKING, Optional, Any, Callable, Awaitable, List
 
-from autobyteus.agent.context.phases import AgentOperationalPhase
+from autobyteus.agent.phases import AgentOperationalPhase
 from autobyteus.agent.events import ( 
     BaseEvent,
     AgentErrorEvent, 
@@ -140,19 +140,19 @@ class AgentWorker:
 
     async def async_run(self) -> None:
         agent_id = self.context.agent_id
-        logger.info(f"AgentWorker '{agent_id}' async_run(): Starting.")
-        
-        # --- Direct Initialization ---
-        initialization_successful = await self._initialize()
-        if not initialization_successful:
-            logger.critical(f"AgentWorker '{agent_id}' failed to initialize. Worker is shutting down.")
-            if self._async_stop_event and not self._async_stop_event.is_set():
-                self._async_stop_event.set()
-            return
-        
-        # --- Main Event Loop ---
-        logger.info(f"AgentWorker '{agent_id}' initialized successfully. Entering main event loop.")
         try:
+            logger.info(f"AgentWorker '{agent_id}' async_run(): Starting.")
+            
+            # --- Direct Initialization ---
+            initialization_successful = await self._initialize()
+            if not initialization_successful:
+                logger.critical(f"AgentWorker '{agent_id}' failed to initialize. Worker is shutting down.")
+                if self._async_stop_event and not self._async_stop_event.is_set():
+                    self._async_stop_event.set()
+                return
+
+            # --- Main Event Loop ---
+            logger.info(f"AgentWorker '{agent_id}' initialized successfully. Entering main event loop.")
             while not self._async_stop_event.is_set(): 
                 try:
                     queue_event_tuple = await asyncio.wait_for(
@@ -183,18 +183,61 @@ class AgentWorker:
             if self.context.state.input_event_queues:
                 await self.context.state.input_event_queues.enqueue_internal_system_event(AgentStoppedEvent())
 
+    async def _shutdown_sequence(self):
+        """
+        The explicit, ordered shutdown sequence for the worker, executed on its own event loop.
+        """
+        agent_id = self.context.agent_id
+        logger.info(f"AgentWorker '{agent_id}': Running shutdown sequence on worker loop.")
+
+        # 1. Clean up resources like the LLM instance.
+        if self.context.llm_instance and hasattr(self.context.llm_instance, 'cleanup'):
+            logger.info(f"AgentWorker '{agent_id}': Running LLM instance cleanup.")
+            try:
+                cleanup_func = self.context.llm_instance.cleanup
+                if asyncio.iscoroutinefunction(cleanup_func):
+                    await cleanup_func()
+                else:
+                    cleanup_func()
+                logger.info(f"AgentWorker '{agent_id}': LLM instance cleanup completed.")
+            except Exception as e:
+                logger.error(f"AgentWorker '{agent_id}': Error during LLM instance cleanup: {e}", exc_info=True)
+
+        # 2. Signal the main event loop to stop.
+        await self._signal_internal_stop()
+        logger.info(f"AgentWorker '{agent_id}': Shutdown sequence completed.")
+
     async def stop(self, timeout: float = 10.0) -> None:
+        """
+        Gracefully stops the worker by scheduling a final shutdown sequence on its
+        event loop, then waiting for the thread to terminate.
+        """
         if not self._is_active or self._stop_initiated:
             return
+        
+        agent_id = self.context.agent_id
+        logger.info(f"AgentWorker '{agent_id}': Stop requested.")
         self._stop_initiated = True
-        if self.get_worker_loop() and self._async_stop_event:
-            future = asyncio.run_coroutine_threadsafe(self._signal_internal_stop(), self.get_worker_loop())
-            try: future.result(timeout=1.0)
-            except Exception: pass
+
+        # Schedule the explicit shutdown sequence on the worker's loop.
+        if self.get_worker_loop():
+            future = self.schedule_coroutine_on_worker_loop(self._shutdown_sequence)
+            try:
+                # Wait for the cleanup and stop signal to be processed.
+                future.result(timeout=max(1.0, timeout-1))
+            except Exception as e:
+                logger.error(f"AgentWorker '{agent_id}': Error during scheduled shutdown sequence: {e}", exc_info=True)
+
+        # Wait for the main thread future to complete.
         if self._thread_future:
-            try: await asyncio.wait_for(asyncio.wrap_future(self._thread_future), timeout=timeout)
-            except asyncio.TimeoutError: logger.warning(f"Timeout waiting for worker thread of '{self.context.agent_id}'.")
+            try:
+                await asyncio.wait_for(asyncio.wrap_future(self._thread_future), timeout=timeout)
+                logger.info(f"AgentWorker '{agent_id}': Worker thread has terminated.")
+            except asyncio.TimeoutError:
+                logger.warning(f"AgentWorker '{agent_id}': Timeout waiting for worker thread to terminate.")
+        
         self._is_active = False
 
+
     def is_alive(self) -> bool:
         return self._thread_future is not None and not self._thread_future.done()

autobyteus/agent/streaming/agent_event_stream.py

@@ -1,3 +1,4 @@
+# file: autobyteus/autobyteus/agent/streaming/agent_event_stream.py
 import asyncio
 import logging
 import traceback
@@ -14,9 +15,16 @@ from autobyteus.agent.streaming.stream_event_payloads import (
     create_agent_operational_phase_transition_data, 
     create_error_event_data,
     create_tool_invocation_approval_requested_data,
+    create_tool_invocation_auto_executing_data,
+    AssistantChunkData,
+    AssistantCompleteResponseData,
+    ToolInteractionLogEntryData,
+    AgentOperationalPhaseTransitionData,
+    ToolInvocationApprovalRequestedData,
+    ToolInvocationAutoExecutingData,
+    ErrorEventData,
     EmptyData,
     StreamDataPayload,
-    ErrorEventData, 
 )
 from .queue_streamer import stream_queue_items 
 from autobyteus.events.event_types import EventType 
@@ -60,8 +68,7 @@ class AgentEventStream(EventEmitter):
         all_agent_event_types = [et for et in EventType if et.name.startswith("AGENT_")]
         
         for event_type in all_agent_event_types:
-            handler = functools.partial(self._handle_notifier_event_sync, event_type=event_type)
-            self.subscribe_from(self._notifier, event_type, handler)
+            self.subscribe_from(self._notifier, event_type, self._handle_notifier_event_sync)
 
     def _handle_notifier_event_sync(self, event_type: EventType, payload: Optional[Any] = None, object_id: Optional[str] = None, **kwargs):
         event_agent_id = kwargs.get("agent_id", self.agent_id) 
@@ -88,13 +95,15 @@ class AgentEventStream(EventEmitter):
             elif event_type == EventType.AGENT_REQUEST_TOOL_INVOCATION_APPROVAL:
                 typed_payload_for_stream_event = create_tool_invocation_approval_requested_data(payload)
                 stream_event_type_for_generic_stream = StreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED
+            elif event_type == EventType.AGENT_TOOL_INVOCATION_AUTO_EXECUTING:
+                typed_payload_for_stream_event = create_tool_invocation_auto_executing_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.TOOL_INVOCATION_AUTO_EXECUTING
             elif event_type == EventType.AGENT_ERROR_OUTPUT_GENERATION:
                 typed_payload_for_stream_event = create_error_event_data(payload)
                 stream_event_type_for_generic_stream = StreamEventType.ERROR_EVENT
             
-            # The other queues are no longer needed, as `all_events` is the single source of truth.
             elif event_type in [EventType.AGENT_DATA_ASSISTANT_CHUNK_STREAM_END, EventType.AGENT_DATA_TOOL_LOG_STREAM_END]:
-                 pass # These events are signals, not data for the unified stream.
+                 pass 
             else:
                  logger.debug(f"AgentEventStream received internal event '{event_type.name}' with no direct stream mapping.")
         
@@ -118,3 +127,47 @@ class AgentEventStream(EventEmitter):
         """The primary method to consume all structured events from the agent."""
         async for event in stream_queue_items(self._generic_stream_event_internal_q, _AES_INTERNAL_SENTINEL, f"agent_{self.agent_id}_all_events"):
             yield event
+
+    # --- Convenience Stream Methods ---
+
+    async def stream_assistant_chunks(self) -> AsyncIterator[AssistantChunkData]:
+        """A convenience async generator that yields only assistant content/reasoning chunks."""
+        async for event in self.all_events():
+            if event.event_type == StreamEventType.ASSISTANT_CHUNK and isinstance(event.data, AssistantChunkData):
+                yield event.data
+
+    async def stream_assistant_final_response(self) -> AsyncIterator[AssistantCompleteResponseData]:
+        """A convenience async generator that yields only the final, complete assistant responses."""
+        async for event in self.all_events():
+            if event.event_type == StreamEventType.ASSISTANT_COMPLETE_RESPONSE and isinstance(event.data, AssistantCompleteResponseData):
+                yield event.data
+
+    async def stream_tool_logs(self) -> AsyncIterator[ToolInteractionLogEntryData]:
+        """A convenience async generator that yields only tool interaction log entries."""
+        async for event in self.all_events():
+            if event.event_type == StreamEventType.TOOL_INTERACTION_LOG_ENTRY and isinstance(event.data, ToolInteractionLogEntryData):
+                yield event.data
+    
+    async def stream_phase_transitions(self) -> AsyncIterator[AgentOperationalPhaseTransitionData]:
+        """A convenience async generator that yields only agent phase transition data."""
+        async for event in self.all_events():
+            if event.event_type == StreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION and isinstance(event.data, AgentOperationalPhaseTransitionData):
+                yield event.data
+
+    async def stream_tool_approval_requests(self) -> AsyncIterator[ToolInvocationApprovalRequestedData]:
+        """A convenience async generator that yields only requests for tool invocation approval."""
+        async for event in self.all_events():
+            if event.event_type == StreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED and isinstance(event.data, ToolInvocationApprovalRequestedData):
+                yield event.data
+
+    async def stream_tool_auto_executing(self) -> AsyncIterator[ToolInvocationAutoExecutingData]:
+        """A convenience async generator that yields only events for tools being auto-executed."""
+        async for event in self.all_events():
+            if event.event_type == StreamEventType.TOOL_INVOCATION_AUTO_EXECUTING and isinstance(event.data, ToolInvocationAutoExecutingData):
+                yield event.data
+
+    async def stream_errors(self) -> AsyncIterator[ErrorEventData]:
+        """A convenience async generator that yields only error events."""
+        async for event in self.all_events():
+            if event.event_type == StreamEventType.ERROR_EVENT and isinstance(event.data, ErrorEventData):
+                yield event.data

autobyteus/agent/streaming/stream_event_payloads.py

@@ -4,7 +4,7 @@ from typing import Dict, Any, Optional, List, Union
 from pydantic import BaseModel, Field
 
 from autobyteus.llm.utils.token_usage import TokenUsage 
-from autobyteus.agent.context.phases import AgentOperationalPhase
+from autobyteus.agent.phases import AgentOperationalPhase
 
 
 logger = logging.getLogger(__name__)
@@ -29,6 +29,8 @@ class AssistantCompleteResponseData(BaseStreamPayload):
 
 class ToolInteractionLogEntryData(BaseStreamPayload):
     log_entry: str
+    tool_invocation_id: str
+    tool_name: str
 
 class AgentOperationalPhaseTransitionData(BaseStreamPayload): 
     new_phase: AgentOperationalPhase 
@@ -48,17 +50,23 @@ class ToolInvocationApprovalRequestedData(BaseStreamPayload):
     tool_name: str
     arguments: Dict[str, Any]
 
+class ToolInvocationAutoExecutingData(BaseStreamPayload):
+    invocation_id: str
+    tool_name: str
+    arguments: Dict[str, Any]
+
 class EmptyData(BaseStreamPayload):
     pass
 
 # Union of all possible data payload types
 StreamDataPayload = Union[
     AssistantChunkData,
-    AssistantCompleteResponseData, # UPDATED in Union
+    AssistantCompleteResponseData, 
     ToolInteractionLogEntryData,
     AgentOperationalPhaseTransitionData, 
     ErrorEventData,
     ToolInvocationApprovalRequestedData,
+    ToolInvocationAutoExecutingData,
     EmptyData
 ]
 
@@ -99,8 +107,7 @@ def create_assistant_chunk_data(chunk_obj: Any) -> AssistantChunkData:
         )
     raise ValueError(f"Cannot create AssistantChunkData from {type(chunk_obj)}")
 
-# RENAMED FACTORY FUNCTION
-def create_assistant_complete_response_data(complete_resp_obj: Any) -> AssistantCompleteResponseData: # RENAMED
+def create_assistant_complete_response_data(complete_resp_obj: Any) -> AssistantCompleteResponseData:
     usage_data = None
     if hasattr(complete_resp_obj, 'usage'):
         usage_data = getattr(complete_resp_obj, 'usage')
@@ -120,25 +127,24 @@ def create_assistant_complete_response_data(complete_resp_obj: Any) -> Assistant
             logger.warning(f"Unsupported usage type {type(usage_data)} for AssistantCompleteResponseData.")
 
     if hasattr(complete_resp_obj, 'content'):
-        return AssistantCompleteResponseData( # Use new class name
+        return AssistantCompleteResponseData(
             content=str(getattr(complete_resp_obj, 'content', '')),
             reasoning=getattr(complete_resp_obj, 'reasoning', None),
             usage=parsed_usage
         )
     elif isinstance(complete_resp_obj, dict): 
-        return AssistantCompleteResponseData( # Use new class name
+        return AssistantCompleteResponseData(
             content=str(complete_resp_obj.get('content', '')),
             reasoning=complete_resp_obj.get('reasoning', None),
             usage=parsed_usage
         )
     raise ValueError(f"Cannot create AssistantCompleteResponseData from {type(complete_resp_obj)}")
 
-def create_tool_interaction_log_entry_data(log_entry: Any) -> ToolInteractionLogEntryData:
-    if isinstance(log_entry, str):
-        return ToolInteractionLogEntryData(log_entry=log_entry)
-    elif isinstance(log_entry, dict) and 'log_entry' in log_entry:
-        return ToolInteractionLogEntryData(log_entry=str(log_entry['log_entry']))
-    raise ValueError(f"Cannot create ToolInteractionLogEntryData from {type(log_entry)}")
+def create_tool_interaction_log_entry_data(log_data: Any) -> ToolInteractionLogEntryData:
+    if isinstance(log_data, dict):
+        if all(k in log_data for k in ['log_entry', 'tool_invocation_id', 'tool_name']):
+            return ToolInteractionLogEntryData(**log_data)
+    raise ValueError(f"Cannot create ToolInteractionLogEntryData from {type(log_data)}. Expected dict with 'log_entry', 'tool_invocation_id', and 'tool_name' keys.")
 
 def create_agent_operational_phase_transition_data(phase_data_dict: Any) -> AgentOperationalPhaseTransitionData: 
     if isinstance(phase_data_dict, dict):
@@ -153,4 +159,9 @@ def create_error_event_data(error_data_dict: Any) -> ErrorEventData:
 def create_tool_invocation_approval_requested_data(approval_data_dict: Any) -> ToolInvocationApprovalRequestedData:
     if isinstance(approval_data_dict, dict):
         return ToolInvocationApprovalRequestedData(**approval_data_dict)
-    raise ValueError(f"Cannot create ToolInvocationApprovalRequestedData from {type(approval_data_dict)}")
+    raise ValueError(f"Cannot create ToolInvocationApprovalRequestedData from {type(approval_data_dict)}")
+
+def create_tool_invocation_auto_executing_data(auto_exec_data_dict: Any) -> ToolInvocationAutoExecutingData:
+    if isinstance(auto_exec_data_dict, dict):
+        return ToolInvocationAutoExecutingData(**auto_exec_data_dict)
+    raise ValueError(f"Cannot create ToolInvocationAutoExecutingData from {type(auto_exec_data_dict)}")

autobyteus/agent/streaming/stream_events.py

@@ -2,7 +2,7 @@
 import logging
 from enum import Enum
 from typing import Dict, Any, Optional, Union, Type 
-from pydantic import BaseModel, Field, AwareDatetime, validator, RootModel 
+from pydantic import BaseModel, Field, AwareDatetime, field_validator, ValidationInfo 
 import datetime
 import uuid 
 
@@ -10,11 +10,12 @@ import uuid
 from .stream_event_payloads import (
     StreamDataPayload, 
     AssistantChunkData,
-    AssistantCompleteResponseData, # UPDATED import
+    AssistantCompleteResponseData,
     ToolInteractionLogEntryData,
     AgentOperationalPhaseTransitionData, 
     ErrorEventData,
     ToolInvocationApprovalRequestedData,
+    ToolInvocationAutoExecutingData,
     EmptyData
 )
 
@@ -26,22 +27,24 @@ class StreamEventType(str, Enum):
     provided by AgentEventStream.
     """
     ASSISTANT_CHUNK = "assistant_chunk"
-    ASSISTANT_COMPLETE_RESPONSE = "assistant_complete_response" # RENAMED from ASSISTANT_FINAL_MESSAGE
+    ASSISTANT_COMPLETE_RESPONSE = "assistant_complete_response"
     TOOL_INTERACTION_LOG_ENTRY = "tool_interaction_log_entry"
-    AGENT_OPERATIONAL_PHASE_TRANSITION = "agent_operational_phase_transition" # RENAMED from AGENT_PHASE_UPDATE
+    AGENT_OPERATIONAL_PHASE_TRANSITION = "agent_operational_phase_transition"
     ERROR_EVENT = "error_event" 
     TOOL_INVOCATION_APPROVAL_REQUESTED = "tool_invocation_approval_requested" 
-    AGENT_IDLE = "agent_idle" # ADDED: New event type for when agent becomes idle.
+    TOOL_INVOCATION_AUTO_EXECUTING = "tool_invocation_auto_executing"
+    AGENT_IDLE = "agent_idle"
 
 
 _STREAM_EVENT_TYPE_TO_PAYLOAD_CLASS: Dict[StreamEventType, Type[BaseModel]] = {
     StreamEventType.ASSISTANT_CHUNK: AssistantChunkData,
-    StreamEventType.ASSISTANT_COMPLETE_RESPONSE: AssistantCompleteResponseData, # UPDATED mapping
+    StreamEventType.ASSISTANT_COMPLETE_RESPONSE: AssistantCompleteResponseData,
     StreamEventType.TOOL_INTERACTION_LOG_ENTRY: ToolInteractionLogEntryData,
-    StreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION: AgentOperationalPhaseTransitionData, # RENAMED mapping
+    StreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION: AgentOperationalPhaseTransitionData,
     StreamEventType.ERROR_EVENT: ErrorEventData,
     StreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED: ToolInvocationApprovalRequestedData,
-    StreamEventType.AGENT_IDLE: AgentOperationalPhaseTransitionData, # ADDED: Mapped to the same payload as phase update
+    StreamEventType.TOOL_INVOCATION_AUTO_EXECUTING: ToolInvocationAutoExecutingData,
+    StreamEventType.AGENT_IDLE: AgentOperationalPhaseTransitionData,
 }
 
 
@@ -72,9 +75,9 @@ class StreamEvent(BaseModel):
         description="Optional ID of the agent that originated this event."
     )
 
-    @validator('data', pre=True, always=True)
-    def validate_data_based_on_event_type(cls, v, values, **kwargs):
-        event_type_value = values.get('event_type')
+    @field_validator('data', mode='before')
+    def validate_data_based_on_event_type(cls, v, info: ValidationInfo):
+        event_type_value = info.data.get('event_type')
         if not event_type_value: 
             return v 
 

autobyteus/agent/system_prompt_processor/base_processor.py

@@ -3,23 +3,26 @@ import logging
 from abc import ABC, abstractmethod
 from typing import TYPE_CHECKING, Dict
 
+from .processor_meta import SystemPromptProcessorMeta
+
 if TYPE_CHECKING:
     from autobyteus.tools.base_tool import BaseTool
     from autobyteus.agent.context import AgentContext
 
 logger = logging.getLogger(__name__)
 
-class BaseSystemPromptProcessor(ABC):
+class BaseSystemPromptProcessor(ABC, metaclass=SystemPromptProcessorMeta):
     """
     Abstract base class for system prompt processors.
     Subclasses should be instantiated and passed to the AgentSpecification.
     """
-    def get_name(self) -> str:
+    @classmethod
+    def get_name(cls) -> str:
         """
         Returns the unique name for this processor.
         Defaults to the class name. Can be overridden by subclasses.
         """
-        return self.__class__.__name__
+        return cls.__name__
 
     @abstractmethod
     def process(self,

autobyteus/agent/system_prompt_processor/processor_meta.py

@@ -38,7 +38,7 @@ class SystemPromptProcessorMeta(ABCMeta):
             # Ensure 'cls' is correctly typed for SystemPromptProcessorDefinition
             definition = SystemPromptProcessorDefinition(name=processor_name, processor_class=cls) # type: ignore
             default_system_prompt_processor_registry.register_processor(definition)
-            logger.info(f"Auto-registered system prompt processor: '{processor_name}' from class {name}")
+            logger.info(f"Auto-registered system prompt processor: '{processor_name}' from class {name} (no schema).")
 
         except AttributeError as e:
             # Catch if get_name is missing

autobyteus/agent/system_prompt_processor/tool_manifest_injector_processor.py

@@ -5,6 +5,7 @@ from typing import Dict, TYPE_CHECKING, List
 from .base_processor import BaseSystemPromptProcessor
 from autobyteus.tools.registry import default_tool_registry, ToolDefinition
 from autobyteus.tools.usage.providers import ToolManifestProvider
+from autobyteus.prompt.prompt_template import PromptTemplate
 
 if TYPE_CHECKING:
     from autobyteus.tools.base_tool import BaseTool
@@ -14,52 +15,65 @@ logger = logging.getLogger(__name__)
 
 class ToolManifestInjectorProcessor(BaseSystemPromptProcessor):
     """
-    Injects a tool manifest into the system prompt, replacing '{{tools}}'.
-    It delegates the generation of the manifest string to a ToolManifestProvider.
+    Injects a tool manifest into the system prompt using Jinja2-style placeholders.
+    It primarily targets the '{{tools}}' variable. It uses PromptTemplate for
+    rendering and delegates manifest generation to a ToolManifestProvider.
     """
-    PLACEHOLDER = "{{tools}}"
+    # The '{{tools}}' placeholder is now handled by Jinja2 via PromptTemplate.
     DEFAULT_PREFIX_FOR_TOOLS_ONLY_PROMPT = "You have access to a set of tools. Use them by outputting the appropriate tool call format. The user can only see the output of the tool, not the call itself. The available tools are:\n\n"
 
     def __init__(self):
         self._manifest_provider = ToolManifestProvider()
         logger.debug(f"{self.get_name()} initialized.")
 
-    def get_name(self) -> str:
+    @classmethod
+    def get_name(cls) -> str:
         return "ToolManifestInjector"
 
     def process(self, system_prompt: str, tool_instances: Dict[str, 'BaseTool'], agent_id: str, context: 'AgentContext') -> str:
-        if self.PLACEHOLDER not in system_prompt:
+        try:
+            prompt_template = PromptTemplate(template=system_prompt)
+        except Exception as e:
+            logger.error(f"Failed to create PromptTemplate from system prompt for agent '{agent_id}'. Error: {e}", exc_info=True)
+            # Return original prompt on Jinja2 parsing failure
             return system_prompt
 
-        is_tools_only_prompt = system_prompt.strip() == self.PLACEHOLDER
-        
-        if not tool_instances:
-            logger.info(f"{self.get_name()}: The '{self.PLACEHOLDER}' placeholder is present, but no tools are instantiated. Replacing with 'No tools available.'")
-            replacement_text = "No tools available for this agent."
-            if is_tools_only_prompt:
-                return self.DEFAULT_PREFIX_FOR_TOOLS_ONLY_PROMPT + replacement_text
-            return system_prompt.replace(self.PLACEHOLDER, f"\n{replacement_text}")
+        # Check if the 'tools' variable is actually in the template
+        if "tools" not in prompt_template.required_vars:
+            return system_prompt
 
-        tool_definitions: List[ToolDefinition] = [
-            td for name in tool_instances if (td := default_tool_registry.get_tool_definition(name))
-        ]
+        # Generate the manifest string for the 'tools' variable.
+        tools_manifest: str
+        if not tool_instances:
+            logger.info(f"{self.get_name()}: The '{{{{tools}}}}' placeholder is present, but no tools are instantiated. Using 'No tools available.'")
+            tools_manifest = "No tools available for this agent."
+        else:
+            tool_definitions: List[ToolDefinition] = [
+                td for name in tool_instances if (td := default_tool_registry.get_tool_definition(name))
+            ]
 
-        llm_provider = context.llm_instance.model.provider if context.llm_instance and context.llm_instance.model else None
+            llm_provider = context.llm_instance.model.provider if context.llm_instance and context.llm_instance.model else None
 
-        try:
-            # Delegate manifest generation to the provider
-            tools_description = self._manifest_provider.provide(
-                tool_definitions=tool_definitions,
-                use_xml=context.config.use_xml_tool_format,
-                provider=llm_provider
-            )
-        except Exception as e:
-            logger.exception(f"An unexpected error occurred during tool manifest generation for agent '{agent_id}': {e}")
-            tools_description = "Error: Could not generate tool descriptions."
+            try:
+                # Delegate manifest generation to the provider
+                tools_manifest = self._manifest_provider.provide(
+                    tool_definitions=tool_definitions,
+                    use_xml=context.config.use_xml_tool_format,
+                    provider=llm_provider
+                )
+            except Exception as e:
+                logger.exception(f"An unexpected error occurred during tool manifest generation for agent '{agent_id}': {e}")
+                tools_manifest = "Error: Could not generate tool descriptions."
         
-        final_replacement_text = f"\n{tools_description}"
+        # Check if the prompt *only* contains the 'tools' variable by rendering with an empty string
+        rendered_without_tools = prompt_template.fill({"tools": ""})
+        is_tools_only_prompt = not rendered_without_tools.strip()
+
         if is_tools_only_prompt:
              logger.info(f"{self.get_name()}: Prompt contains only the tools placeholder. Prepending default instructions.")
-             return self.DEFAULT_PREFIX_FOR_TOOLS_ONLY_PROMPT + tools_description
-
-        return system_prompt.replace(self.PLACEHOLDER, final_replacement_text)
+             return self.DEFAULT_PREFIX_FOR_TOOLS_ONLY_PROMPT + tools_manifest
+        else:
+            # For prompts that contain other text, add a newline for better formatting before filling the template.
+            tools_description_with_newline = f"\n{tools_manifest}"
+            final_prompt = prompt_template.fill({"tools": tools_description_with_newline})
+            return final_prompt

autobyteus/agent/tool_invocation.py

@@ -1,5 +1,7 @@
 # file: autobyteus/autobyteus/agent/tool_invocation.py
 import uuid
+import hashlib
+import json
 from typing import Optional, Dict, Any
 
 class ToolInvocation:
@@ -11,11 +13,36 @@ class ToolInvocation:
             name: The name of the tool to be invoked.
             arguments: A dictionary of arguments for the tool.
             id: Optional. A unique identifier for this tool invocation.
-                If None, a new UUID will be generated.
+                If None, a deterministic ID will be generated based on the tool name and arguments.
         """
         self.name: Optional[str] = name
         self.arguments: Optional[Dict[str, Any]] = arguments
-        self.id: str = id if id is not None else str(uuid.uuid4())
+        
+        if id is not None:
+            self.id: str = id
+        elif self.name is not None and self.arguments is not None:
+            self.id: str = self._generate_deterministic_id(self.name, self.arguments)
+        else:
+            # Fallback to UUID if name/args are not provided during init, though this is an edge case.
+            self.id: str = f"call_{uuid.uuid4().hex}"
+
+    @staticmethod
+    def _generate_deterministic_id(name: str, arguments: Dict[str, Any]) -> str:
+        """
+        Generates a deterministic ID for the tool invocation based on its content.
+        """
+        # Create a canonical representation of the arguments
+        # sort_keys=True ensures that the order of keys doesn't change the hash
+        canonical_args = json.dumps(arguments, sort_keys=True, separators=(',', ':'))
+        
+        # Create a string to hash
+        hash_string = f"{name}:{canonical_args}"
+        
+        # Use SHA256 for a robust hash
+        sha256_hash = hashlib.sha256(hash_string.encode('utf-8')).hexdigest()
+        
+        # Prepend a prefix for clarity and use the full hash.
+        return f"call_{sha256_hash}"
 
     def is_valid(self) -> bool:
         """
@@ -27,4 +54,3 @@ class ToolInvocation:
     def __repr__(self) -> str:
         return (f"ToolInvocation(id='{self.id}', name='{self.name}', "
                 f"arguments={self.arguments})")
-

autobyteus/agent/utils/wait_for_idle.py

@@ -6,7 +6,7 @@ from typing import Optional
 from autobyteus.agent.agent import Agent
 from autobyteus.agent.streaming.agent_event_stream import AgentEventStream
 from autobyteus.agent.streaming.stream_events import StreamEventType
-from autobyteus.agent.context.phases import AgentOperationalPhase
+from autobyteus.agent.phases import AgentOperationalPhase
 
 logger = logging.getLogger(__name__)
 

autobyteus/agent/workspace/__init__.py

@@ -3,7 +3,9 @@
 Defines the agent's workspace or working environment.
 """
 from .base_workspace import BaseAgentWorkspace
+from .workspace_config import WorkspaceConfig
 
 __all__ = [
     "BaseAgentWorkspace",
+    "WorkspaceConfig",
 ]