autobyteus 1.2.0__py3-none-any.whl → 1.2.3__py3-none-any.whl

autobyteus/agent/streaming/stream_events.py

@@ -1,129 +1,4 @@
-# file: autobyteus/autobyteus/agent/streaming/stream_events.py
-import logging
-from enum import Enum
-from typing import Dict, Any, Optional, Union, Type 
-from pydantic import BaseModel, Field, AwareDatetime, field_validator, ValidationInfo 
-import datetime
-import uuid 
+"""Compatibility shim for stream events."""
+from .events.stream_events import *
 
-# Import the payload models
-from .stream_event_payloads import (
-    StreamDataPayload, 
-    AssistantChunkData,
-    AssistantCompleteResponseData,
-    ToolInteractionLogEntryData,
-    AgentOperationalPhaseTransitionData, 
-    ErrorEventData,
-    ToolInvocationApprovalRequestedData,
-    ToolInvocationAutoExecutingData,
-    SystemTaskNotificationData, # NEW
-    EmptyData
-)
-
-logger = logging.getLogger(__name__)
-
-class StreamEventType(str, Enum):
-    """
-    Defines the types of events that can appear in a unified agent output stream
-    provided by AgentEventStream.
-    """
-    ASSISTANT_CHUNK = "assistant_chunk"
-    ASSISTANT_COMPLETE_RESPONSE = "assistant_complete_response"
-    TOOL_INTERACTION_LOG_ENTRY = "tool_interaction_log_entry"
-    AGENT_OPERATIONAL_PHASE_TRANSITION = "agent_operational_phase_transition"
-    ERROR_EVENT = "error_event" 
-    TOOL_INVOCATION_APPROVAL_REQUESTED = "tool_invocation_approval_requested" 
-    TOOL_INVOCATION_AUTO_EXECUTING = "tool_invocation_auto_executing"
-    SYSTEM_TASK_NOTIFICATION = "system_task_notification" # NEW
-    AGENT_IDLE = "agent_idle"
-
-
-_STREAM_EVENT_TYPE_TO_PAYLOAD_CLASS: Dict[StreamEventType, Type[BaseModel]] = {
-    StreamEventType.ASSISTANT_CHUNK: AssistantChunkData,
-    StreamEventType.ASSISTANT_COMPLETE_RESPONSE: AssistantCompleteResponseData,
-    StreamEventType.TOOL_INTERACTION_LOG_ENTRY: ToolInteractionLogEntryData,
-    StreamEventType.AGENT_OPERATIONAL_PHASE_TRANSITION: AgentOperationalPhaseTransitionData,
-    StreamEventType.ERROR_EVENT: ErrorEventData,
-    StreamEventType.TOOL_INVOCATION_APPROVAL_REQUESTED: ToolInvocationApprovalRequestedData,
-    StreamEventType.TOOL_INVOCATION_AUTO_EXECUTING: ToolInvocationAutoExecutingData,
-    StreamEventType.SYSTEM_TASK_NOTIFICATION: SystemTaskNotificationData, # NEW
-    StreamEventType.AGENT_IDLE: AgentOperationalPhaseTransitionData,
-}
-
-
-class StreamEvent(BaseModel):
-    """
-    Pydantic model for a unified, typed event in an agent's output stream.
-    The 'data' field is now a discriminated union of specific payload models
-    based on 'event_type'.
-    """
-    event_id: str = Field(
-        default_factory=lambda: str(uuid.uuid4()), 
-        description="Unique identifier for the event."
-    )
-    timestamp: AwareDatetime = Field(
-        default_factory=lambda: datetime.datetime.now(datetime.timezone.utc),
-        description="Timestamp of when the event was created (UTC)."
-    )
-    event_type: StreamEventType = Field(
-        ..., 
-        description="The type of the event. This acts as the discriminator."
-    )
-    data: StreamDataPayload = Field( 
-        ..., 
-        description="Payload of the event, specific to the event_type."
-    )
-    agent_id: Optional[str] = Field(
-        default=None, 
-        description="Optional ID of the agent that originated this event."
-    )
-
-    @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 
-
-        if isinstance(event_type_value, str):
-            try:
-                event_type = StreamEventType(event_type_value)
-            except ValueError: # pragma: no cover
-                logger.error(f"Invalid event_type string '{event_type_value}' for validation.")
-                raise ValueError(f"Invalid event_type string '{event_type_value}'")
-        elif isinstance(event_type_value, StreamEventType):
-            event_type = event_type_value
-        else: # pragma: no cover
-            logger.error(f"event_type is of unexpected type {type(event_type_value)} during validation.")
-            raise TypeError(f"event_type is of unexpected type {type(event_type_value)}")
-
-
-        payload_class = _STREAM_EVENT_TYPE_TO_PAYLOAD_CLASS.get(event_type)
-        
-        if payload_class:
-            if isinstance(v, payload_class): 
-                return v
-            if isinstance(v, dict):
-                try:
-                    return payload_class(**v)
-                except Exception as e:
-                    logger.error(f"Failed to parse dict into {payload_class.__name__} for event_type {event_type.value}: {e}. Dict was: {v}")
-                    raise ValueError(f"Data for event type {event_type.value} does not match expected model {payload_class.__name__}.") from e
-            logger.error(f"Data for event type {event_type.value} is of unexpected type {type(v)}. Expected dict or {payload_class.__name__}.")
-            raise ValueError(f"Data for event type {event_type.value} is of unexpected type {type(v)}.")
-        
-        logger.warning(f"No specific payload class mapped for event_type: {event_type.value}. Raw data: {v}")
-        if isinstance(v, dict): 
-            return v
-        return v
-
-
-    class Config:
-        populate_by_name = True 
-
-    def __repr__(self) -> str:
-        return (f"<StreamEvent event_id='{self.event_id}', agent_id='{self.agent_id}', "
-                f"type='{self.event_type.value}', timestamp='{self.timestamp.isoformat()}', data_type='{type(self.data).__name__}'>")
-
-    def __str__(self) -> str:
-        return (f"StreamEvent[{self.event_type.value}] (ID: {self.event_id}, Agent: {self.agent_id or 'N/A'}): "
-                f"Data: {self.data!r}")
+__all__ = ["StreamEvent", "StreamEventType"]

autobyteus/agent/streaming/streaming_handler_factory.py

@@ -0,0 +1,4 @@
+"""Compatibility shim for StreamingResponseHandlerFactory."""
+from .handlers.streaming_handler_factory import StreamingResponseHandlerFactory
+
+__all__ = ["StreamingResponseHandlerFactory"]

autobyteus/agent/streaming/streaming_response_handler.py

@@ -0,0 +1,4 @@
+"""Compatibility shim for StreamingResponseHandler."""
+from .handlers.streaming_response_handler import StreamingResponseHandler
+
+__all__ = ["StreamingResponseHandler"]

autobyteus/agent/streaming/streams/__init__.py

@@ -0,0 +1,5 @@
+"""Stream implementations for agents/teams."""
+
+from .agent_event_stream import AgentEventStream
+
+__all__ = ["AgentEventStream"]

autobyteus/agent/streaming/streams/agent_event_stream.py

@@ -0,0 +1,197 @@
+# file: autobyteus/autobyteus/agent/streaming/agent_event_stream.py
+import asyncio
+import logging
+import queue as standard_queue
+from typing import AsyncIterator, Any, TYPE_CHECKING, Optional, Union
+from ..events.stream_events import StreamEvent, StreamEventType
+from ..events.stream_event_payloads import (
+    create_assistant_chunk_data,
+    create_assistant_complete_response_data,
+    create_tool_interaction_log_entry_data,
+    create_agent_status_update_data,
+    create_error_event_data,
+    create_tool_invocation_approval_requested_data,
+    create_tool_invocation_auto_executing_data,
+    create_segment_event_data,
+    create_system_task_notification_data, # NEW
+    create_inter_agent_message_data, # NEW
+    create_todo_list_update_data,
+    create_artifact_persisted_data, # NEW
+    create_artifact_updated_data, # NEW
+    AssistantChunkData,
+    AssistantCompleteResponseData,
+    ToolInteractionLogEntryData,
+    AgentStatusUpdateData,
+    ToolInvocationApprovalRequestedData,
+    ToolInvocationAutoExecutingData,
+    SegmentEventData,
+    ErrorEventData,
+    SystemTaskNotificationData, # NEW
+    InterAgentMessageData, # NEW
+    ToDoListUpdateData,
+    ArtifactPersistedData, # NEW
+    ArtifactUpdatedData, # NEW
+    StreamDataPayload,
+)
+from ..utils.queue_streamer import stream_queue_items
+from autobyteus.events.event_types import EventType 
+from autobyteus.events.event_emitter import EventEmitter 
+
+if TYPE_CHECKING:
+    from autobyteus.agent.agent import Agent
+    from autobyteus.agent.events.notifiers import AgentExternalEventNotifier
+
+logger = logging.getLogger(__name__)
+
+_AES_INTERNAL_SENTINEL = object()
+
+class AgentEventStream(EventEmitter): 
+    def __init__(self, agent: 'Agent'):
+        super().__init__() 
+        
+        from autobyteus.agent.agent import Agent as ConcreteAgent 
+        if not isinstance(agent, ConcreteAgent):
+            raise TypeError(f"AgentEventStream requires an Agent instance, got {type(agent).__name__}.")
+
+        self.agent_id: str = agent.agent_id
+        
+        self._generic_stream_event_internal_q: standard_queue.Queue[Union[StreamEvent, object]] = standard_queue.Queue()
+
+        self._notifier: Optional['AgentExternalEventNotifier'] = None
+        if agent.context and agent.context.status_manager: 
+            self._notifier = agent.context.status_manager.notifier
+        
+        if not self._notifier:
+            logger.error(f"AgentEventStream for '{self.agent_id}': Notifier not available. No events will be streamed.")
+            return
+
+        self._register_listeners()
+        
+        logger.info(f"AgentEventStream (ID: {self.object_id}) initialized for agent_id '{self.agent_id}'. Subscribed to notifier.")
+
+    def _register_listeners(self):
+        """Subscribes this instance's handler to all relevant events from the notifier."""
+        all_agent_event_types = [et for et in EventType if et.name.startswith("AGENT_")]
+        
+        for event_type in all_agent_event_types:
+            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) 
+        
+        typed_payload_for_stream_event: Optional[StreamDataPayload] = None
+        stream_event_type_for_generic_stream: Optional[StreamEventType] = None
+
+        try:
+            if event_type == EventType.AGENT_STATUS_UPDATED:
+                typed_payload_for_stream_event = create_agent_status_update_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.AGENT_STATUS_UPDATED
+            elif event_type == EventType.AGENT_DATA_ASSISTANT_CHUNK:
+                typed_payload_for_stream_event = create_assistant_chunk_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.ASSISTANT_CHUNK
+            elif event_type == EventType.AGENT_DATA_ASSISTANT_COMPLETE_RESPONSE:
+                typed_payload_for_stream_event = create_assistant_complete_response_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.ASSISTANT_COMPLETE_RESPONSE
+            elif event_type == EventType.AGENT_DATA_TOOL_LOG:
+                typed_payload_for_stream_event = create_tool_interaction_log_entry_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.TOOL_INTERACTION_LOG_ENTRY
+            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_DATA_SEGMENT_EVENT:
+                typed_payload_for_stream_event = create_segment_event_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.SEGMENT_EVENT
+            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
+            # NEW MAPPING
+            elif event_type == EventType.AGENT_DATA_SYSTEM_TASK_NOTIFICATION_RECEIVED:
+                typed_payload_for_stream_event = create_system_task_notification_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.SYSTEM_TASK_NOTIFICATION
+            elif event_type == EventType.AGENT_DATA_INTER_AGENT_MESSAGE_RECEIVED:
+                typed_payload_for_stream_event = create_inter_agent_message_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.INTER_AGENT_MESSAGE
+            elif event_type == EventType.AGENT_DATA_TODO_LIST_UPDATED:
+                typed_payload_for_stream_event = create_todo_list_update_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.AGENT_TODO_LIST_UPDATE
+            # NEW MAPPING
+            elif event_type == EventType.AGENT_ARTIFACT_PERSISTED:
+                typed_payload_for_stream_event = create_artifact_persisted_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.ARTIFACT_PERSISTED
+            elif event_type == EventType.AGENT_ARTIFACT_UPDATED:
+                typed_payload_for_stream_event = create_artifact_updated_data(payload)
+                stream_event_type_for_generic_stream = StreamEventType.ARTIFACT_UPDATED
+            
+            elif event_type == EventType.AGENT_DATA_TOOL_LOG_STREAM_END:
+                 pass 
+            else:
+                 logger.debug(f"AgentEventStream received internal event '{event_type.name}' with no direct stream mapping.")
+        
+        except Exception as e:
+            logger.error(f"AgentEventStream error processing payload for event '{event_type.name}': {e}", exc_info=True)
+
+        if typed_payload_for_stream_event and stream_event_type_for_generic_stream:
+            stream_event = StreamEvent(
+                agent_id=event_agent_id, 
+                event_type=stream_event_type_for_generic_stream, 
+                data=typed_payload_for_stream_event
+            )
+            self._generic_stream_event_internal_q.put(stream_event)
+
+    async def close(self):
+        logger.info(f"AgentEventStream (ID: {self.object_id}) for '{self.agent_id}': close() called. Unsubscribing all listeners and signaling.")
+        self.unsubscribe_all_listeners()
+        # Standard queue.put is non-blocking for the unbounded queue we use here.
+        self._generic_stream_event_internal_q.put(_AES_INTERNAL_SENTINEL)
+
+    async def all_events(self) -> AsyncIterator[StreamEvent]:
+        """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_status_updates(self) -> AsyncIterator[AgentStatusUpdateData]:
+        """A convenience async generator that yields only agent status update data."""
+        async for event in self.all_events():
+            if event.event_type == StreamEventType.AGENT_STATUS_UPDATED and isinstance(event.data, AgentStatusUpdateData):
+                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/utils/__init__.py

@@ -0,0 +1,5 @@
+"""Streaming utilities."""
+
+from .queue_streamer import stream_queue_items
+
+__all__ = ["stream_queue_items"]

autobyteus/agent/streaming/utils/queue_streamer.py

@@ -0,0 +1,59 @@
+# file: autobyteus/autobyteus/agent/streaming/queue_streamer.py
+import asyncio
+import logging
+from typing import TypeVar, AsyncIterator, Union, Any
+import queue as standard_queue
+
+logger = logging.getLogger(__name__)
+
+T = TypeVar('T')
+
+async def stream_queue_items(
+    queue: standard_queue.Queue[Union[T, object]], 
+    sentinel: object, 
+    source_name: str = "unspecified_queue" 
+) -> AsyncIterator[T]:
+    """
+    Asynchronously iterates over a standard `queue.Queue`, yielding items of type T
+    until a specific sentinel object is encountered. This is designed to be used
+    from an async context to consume from a queue populated by a synchronous/threaded context.
+
+    Args:
+        queue: The standard `queue.Queue` to stream items from.
+        sentinel: The unique object used to signal the end of data in the queue.
+        source_name: An optional identifier for the queue source, used in logging.
+
+    Yields:
+        Items of type T from the queue.
+
+    Raises:
+        TypeError: If queue is not a `queue.Queue`.
+        ValueError: If sentinel is None.
+        asyncio.CancelledError: If the generator is cancelled.
+        Exception: Propagates exceptions encountered during queue.get().
+    """
+    if not isinstance(queue, standard_queue.Queue):
+        raise TypeError(f"queue must be an instance of queue.Queue for source '{source_name}'.")
+    if sentinel is None: 
+        raise ValueError(f"sentinel object cannot be None for source '{source_name}'.")
+
+    logger.debug(f"Starting to stream items from queue '{source_name}'.")
+    try:
+        while True:
+            try:
+                item: Any = queue.get_nowait()
+            except standard_queue.Empty:
+                await asyncio.sleep(0.01)
+                continue
+            if item is sentinel:
+                logger.debug(f"Sentinel {sentinel!r} received from queue '{source_name}'. Ending stream.")
+                break
+            yield item  # type: ignore
+    except asyncio.CancelledError:
+        logger.info(f"Stream from queue '{source_name}' was cancelled.")
+        raise 
+    except Exception as e:
+        logger.error(f"Error streaming from queue '{source_name}': {e}", exc_info=True)
+        raise 
+    finally:
+        logger.debug(f"Exiting stream_queue_items for queue '{source_name}'.")

autobyteus/agent/system_prompt_processor/__init__.py

@@ -6,9 +6,11 @@ from .base_processor import BaseSystemPromptProcessor
 
 # Import concrete processors here to make them easily accessible for instantiation
 from .tool_manifest_injector_processor import ToolManifestInjectorProcessor
+from .available_skills_processor import AvailableSkillsProcessor
 
 
 __all__ = [
     "BaseSystemPromptProcessor",
     "ToolManifestInjectorProcessor",
+    "AvailableSkillsProcessor",
 ]

autobyteus/agent/system_prompt_processor/available_skills_processor.py

@@ -0,0 +1,96 @@
+import logging
+from typing import TYPE_CHECKING, Dict
+from autobyteus.agent.system_prompt_processor.base_processor import BaseSystemPromptProcessor
+from autobyteus.skills.registry import SkillRegistry
+
+if TYPE_CHECKING:
+    from autobyteus.tools.base_tool import BaseTool
+    from autobyteus.agent.context import AgentContext
+
+logger = logging.getLogger(__name__)
+
+class AvailableSkillsProcessor(BaseSystemPromptProcessor):
+    """
+    A system prompt processor that injects information about available skills.
+    For preloaded skills (defined in config), it injects the full map.
+    For other skills, it injects a summary (awareness).
+    """
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "AvailableSkillsProcessor"
+
+    @classmethod
+    def is_mandatory(cls) -> bool:
+        return True
+
+    def process(self,
+                system_prompt: str,
+                tool_instances: Dict[str, 'BaseTool'],
+                agent_id: str,
+                context: 'AgentContext') -> str:
+        registry = SkillRegistry()
+        all_skills = registry.list_skills()
+        
+        if not all_skills:
+            logger.info(f"Agent '{agent_id}': No skills found in registry. Skipping injection.")
+            return system_prompt
+
+        # Preloaded skills from config
+        preloaded_skills_names = getattr(context.config, 'skills', [])
+        
+        # Build catalog (table of contents) for all skills
+        catalog_entries = []
+        detailed_sections = []
+
+        for skill in all_skills:
+            # Every skill goes in the catalog
+            catalog_entries.append(f"- **{skill.name}**: {skill.description}")
+            
+            # Preloaded skills also get detailed content
+            if skill.name in preloaded_skills_names:
+                detailed_sections.append(
+                    f"""#### {skill.name}
+**Root Path:** `{skill.root_path}`
+
+{skill.content}""")
+
+        # Build the skills block
+        skills_block = "\n\n## Agent Skills\n"
+        
+        # Catalog section (like table of contents)
+        skills_block += "### Skill Catalog\n"
+        skills_block += "\n".join(catalog_entries) + "\n"
+        skills_block += "\nTo load a skill not shown in detail below, use the `load_skill` tool.\n"
+        
+        # Critical rules section (applies to ALL skills)
+        if detailed_sections:
+            skills_block += """
+### Critical Rules for Using Skills
+
+> **Path Resolution Required for Skill Files**
+> 
+> Skill instructions use relative paths (e.g., `./scripts/run.sh` or `scripts/run.sh`) to refer to internal files.
+> However, standard tools resolve relative paths against the User's Workspace, not the skill directory.
+> 
+> When using ANY file from a skill, you MUST convert its path to ABSOLUTE:
+> `Root Path` + `Relative Path` = `Absolute Path`
+> 
+> **Examples:**
+> 1. Root Path: `/path/to/skill`
+>    Relative: `./scripts/run.sh`
+>    Result: `/path/to/skill/scripts/run.sh`
+> 
+> 2. Root Path: `/path/to/skill`
+>    Relative: `scripts/run.sh`
+>    Result: `/path/to/skill/scripts/run.sh`
+
+"""
+        
+        # Detailed content section (like reading specific chapters)
+        if detailed_sections:
+            skills_block += "### Skill Details\n"
+            skills_block += "\n".join(detailed_sections) + "\n"
+
+        logger.info(f"Agent '{agent_id}': Injected {len(catalog_entries)} skills in catalog, {len(detailed_sections)} with details.")
+        return system_prompt + skills_block

autobyteus/agent/system_prompt_processor/base_processor.py

@@ -61,4 +61,4 @@ class BaseSystemPromptProcessor(ABC, metaclass=SystemPromptProcessorMeta):
         raise NotImplementedError("Subclasses must implement the 'process' method.")
 
     def __repr__(self) -> str:
-        return f"<{self.__class__.__name__}>"
+        return f"<{self.__class__.__name__}>"

autobyteus/agent/system_prompt_processor/processor_meta.py

@@ -26,12 +26,25 @@ class SystemPromptProcessorMeta(ABCMeta):
             logger.debug(f"Skipping registration for abstract system prompt processor class: {name}")
             return
 
+        if "get_name" not in dct:
+            logger.error(
+                f"System prompt processor class {name} is missing required static/class method 'get_name'. Skipping registration."
+            )
+            return
+
         try:
             # Get static/class info from the class being defined
-            processor_name = cls.get_name()
+            try:
+                processor_name = cls.get_name()
+            except TypeError:
+                # Fallback for instance-level get_name overrides
+                instance = cls()
+                processor_name = instance.get_name()
 
             if not processor_name or not isinstance(processor_name, str):
-                logger.error(f"System prompt processor class {name} must return a valid string from static get_name(). Skipping registration.")
+                logger.error(
+                    f"System prompt processor class {name} must return a valid string from static get_name(). Skipping registration."
+                )
                 return
             
             # Create definition using name and the class itself