flock-core 0.5.0b1__py3-none-any.whl → 0.5.0b3__py3-none-any.whl

flock/cli/manage_agents.py

@@ -105,7 +105,7 @@ def _list_agents(flock: Flock):
         model = agent.model or flock.model or "Default"
 
         # Format description (truncate if too long)
-        description = agent.resolved_description
+        description = agent.description
         if description and len(description) > 30:
             description = description[:27] + "..."
         elif not description:
@@ -165,7 +165,7 @@ def _view_agent_details(agent: FlockAgent):
 
     basic_info.add_row("Name", agent.name)
     basic_info.add_row("Model", str(agent.model or "Default"))
-    basic_info.add_row("Description", agent.resolved_description if agent.resolved_description else "N/A")
+    basic_info.add_row("Description", agent.description if agent.description else "N/A")
     basic_info.add_row("Input", str(agent.input))
     basic_info.add_row("Output", str(agent.output))
     basic_info.add_row("Write to File", str(agent.config.write_to_file))
@@ -339,7 +339,7 @@ def _edit_agent(flock: Flock):
     console.print(f"\n[bold underline]Details for Agent: {agent.name}[/]")
     basic_info = Table(show_header=False, box=Box.ROUNDED, padding=(0, 2))
     basic_info.add_row("Name", agent.name)
-    description = agent.resolved_description
+    description = agent.description
     basic_info.add_row("Description", description if description else "N/A")
     basic_info.add_row("Model", agent.model or "Flock Default")
     basic_info.add_row("Input Signature", str(agent.input))

flock/components/evaluation/declarative_evaluation_component.py

@@ -12,12 +12,12 @@ with workflow.unsafe.imports_passed_through():
 from pydantic import Field, PrivateAttr
 
 from flock.core.component.agent_component_base import AgentComponentConfig
-from flock.core.component.evaluation_component_base import EvaluationComponentBase
+from flock.core.component.evaluation_component import EvaluationComponent
 from flock.core.context.context import FlockContext
-from flock.core.registry import flock_component
 from flock.core.logging.logging import get_logger
 from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
 from flock.core.mixin.prompt_parser import PromptParserMixin
+from flock.core.registry import flock_component
 
 logger = get_logger("components.evaluation.declarative")
 
@@ -45,7 +45,7 @@ class DeclarativeEvaluationConfig(AgentComponentConfig):
 
 @flock_component(config_class=DeclarativeEvaluationConfig)
 class DeclarativeEvaluationComponent(
-    EvaluationComponentBase, DSPyIntegrationMixin, PromptParserMixin
+    EvaluationComponent, DSPyIntegrationMixin, PromptParserMixin
 ):
     """Evaluation component that uses DSPy for generation.
     
@@ -58,7 +58,7 @@ class DeclarativeEvaluationComponent(
         default_factory=DeclarativeEvaluationConfig,
         description="Evaluation configuration",
     )
-    
+
     _cost: float = PrivateAttr(default=0.0)
     _lm_history: list = PrivateAttr(default_factory=list)
 
@@ -75,7 +75,7 @@ class DeclarativeEvaluationComponent(
     ) -> dict[str, Any]:
         """Core evaluation logic using DSPy - migrated from DeclarativeEvaluator."""
         logger.debug(f"Starting declarative evaluation for component '{self.name}'")
-        
+
         # Setup DSPy context with LM (directly from original implementation)
         with dspy.context(
             lm=dspy.LM(
@@ -89,14 +89,14 @@ class DeclarativeEvaluationComponent(
             try:
                 from rich.console import Console
                 console = Console()
-                
+
                 # Create DSPy signature from agent definition
                 _dspy_signature = self.create_dspy_signature_class(
                     agent.name,
                     agent.description,
                     f"{agent.input} -> {agent.output}",
                 )
-                
+
                 # Get output field names for streaming
                 output_field_names = list(_dspy_signature.output_fields.keys())
                 if not output_field_names:
@@ -113,7 +113,7 @@ class DeclarativeEvaluationComponent(
                     mcp_tools=mcp_tools or [],
                     kwargs=self.config.kwargs,
                 )
-                
+
             except Exception as setup_error:
                 logger.error(
                     f"Error setting up DSPy task for agent '{agent.name}': {setup_error}",
@@ -132,7 +132,7 @@ class DeclarativeEvaluationComponent(
     async def _execute_streaming(self, agent_task, inputs: dict[str, Any], agent: Any, console) -> dict[str, Any]:
         """Execute DSPy program in streaming mode (from original implementation)."""
         logger.info(f"Evaluating agent '{agent.name}' with async streaming.")
-        
+
         if not callable(agent_task):
             logger.error("agent_task is not callable, cannot stream.")
             raise TypeError("DSPy task could not be created or is not callable.")
@@ -167,7 +167,7 @@ class DeclarativeEvaluationComponent(
     async def _execute_standard(self, agent_task, inputs: dict[str, Any], agent: Any) -> dict[str, Any]:
         """Execute DSPy program in standard mode (from original implementation)."""
         logger.info(f"Evaluating agent '{agent.name}' without streaming.")
-        
+
         try:
             # Ensure the call is awaited if the underlying task is async
             result_obj = await agent_task.acall(**inputs)

flock/components/routing/conditional_routing_component.py

@@ -8,11 +8,12 @@ from typing import TYPE_CHECKING, Any, Literal
 from pydantic import Field, model_validator
 
 from flock.core.component.agent_component_base import AgentComponentConfig
-from flock.core.component.routing_component_base import RoutingComponentBase
+from flock.core.component.routing_component import RoutingComponent
 from flock.core.context.context import FlockContext
-from flock.core.registry import flock_component, get_registry
+
 # HandOffRequest removed - using agent.next_agent directly
 from flock.core.logging.logging import get_logger
+from flock.core.registry import flock_component, get_registry
 
 if TYPE_CHECKING:
     from flock.core.flock_agent import FlockAgent
@@ -148,7 +149,7 @@ class ConditionalRoutingConfig(AgentComponentConfig):
 
 
 @flock_component(config_class=ConditionalRoutingConfig)
-class ConditionalRoutingComponent(RoutingComponentBase):
+class ConditionalRoutingComponent(RoutingComponent):
     """Routes workflow based on evaluating a condition against a value in the FlockContext.
     
     Supports various built-in checks (string, number, list, type, bool, existence)
@@ -436,7 +437,7 @@ class ConditionalRoutingComponent(RoutingComponentBase):
 
             next_agent = cfg.success_agent or None  # Stop chain if None
             logger.debug(f"Success route target: '{next_agent}'")
-            
+
             agent.next_agent = next_agent  # Set directly on agent
 
         else:
@@ -481,7 +482,7 @@ class ConditionalRoutingComponent(RoutingComponentBase):
                     logger.debug(
                         f"Failure route target (after retries): '{next_agent}'"
                     )
-                    
+
                     agent.next_agent = next_agent
             else:
                 # --- No Retry Logic ---
@@ -489,5 +490,5 @@ class ConditionalRoutingComponent(RoutingComponentBase):
                     cfg.failure_agent or None
                 )  # Use failure agent or stop
                 logger.debug(f"Failure route target (no retry): '{next_agent}'")
-                
+
                 agent.next_agent = next_agent

flock/components/routing/default_routing_component.py

@@ -7,10 +7,10 @@ from typing import TYPE_CHECKING, Any
 from pydantic import Field
 
 from flock.core.component.agent_component_base import AgentComponentConfig
-from flock.core.component.routing_component_base import RoutingComponentBase
+from flock.core.component.routing_component import RoutingComponent
 from flock.core.context.context import FlockContext
-from flock.core.registry import flock_component
 from flock.core.logging.logging import get_logger
+from flock.core.registry import flock_component
 
 if TYPE_CHECKING:
     from flock.core.flock_agent import FlockAgent
@@ -27,7 +27,7 @@ class DefaultRoutingConfig(AgentComponentConfig):
 
 
 @flock_component(config_class=DefaultRoutingConfig)
-class DefaultRoutingComponent(RoutingComponentBase):
+class DefaultRoutingComponent(RoutingComponent):
     """Default routing component implementation.
 
     This router simply uses the configured hand_off property to determine the next agent.

flock/components/routing/llm_routing_component.py

@@ -8,11 +8,12 @@ import litellm
 from pydantic import Field
 
 from flock.core.component.agent_component_base import AgentComponentConfig
-from flock.core.component.routing_component_base import RoutingComponentBase
+from flock.core.component.routing_component import RoutingComponent
 from flock.core.context.context import FlockContext
-from flock.core.registry import flock_component
+
 # HandOffRequest removed - using agent.next_agent directly
 from flock.core.logging.logging import get_logger
+from flock.core.registry import flock_component
 
 if TYPE_CHECKING:
     from flock.core.flock_agent import FlockAgent
@@ -53,7 +54,7 @@ If no agent is suitable, use "next_agent": "" to end the workflow.""",
 
 
 @flock_component(config_class=LLMRoutingConfig)
-class LLMRoutingComponent(RoutingComponentBase):
+class LLMRoutingComponent(RoutingComponent):
     """Router that uses an LLM to determine the next agent in a workflow.
     
     This component analyzes the current agent's output and uses an LLM to
@@ -79,7 +80,7 @@ class LLMRoutingComponent(RoutingComponentBase):
     ) -> list[str]:
         """Get list of available agent names except the current one."""
         available = []
-        for agent_name in agent_definitions.keys():
+        for agent_name in agent_definitions:
             if agent_name != current_agent_name:
                 available.append(agent_name)
         return available
@@ -91,17 +92,16 @@ class LLMRoutingComponent(RoutingComponentBase):
         available_agents: list[str],
     ) -> str:
         """Create the prompt for LLM agent selection."""
-        
         # Format available agents
         agents_list = []
         for agent_name in available_agents:
             agents_list.append(f"- {agent_name}")
-        
+
         available_agents_str = "\n".join(agents_list) if agents_list else "None available"
-        
-        # Format current output 
+
+        # Format current output
         current_output = json.dumps(result, indent=2) if result else "No output"
-        
+
         return self.config.prompt_template.format(
             current_agent_name=current_agent.name,
             current_output=current_output,
@@ -115,14 +115,13 @@ class LLMRoutingComponent(RoutingComponentBase):
         available_agents: list[str],
     ) -> tuple[str, float]:
         """Use an LLM to select the best next agent."""
-        
         if not available_agents:
             logger.warning("No available agents for LLM routing")
             return "", 0.0
 
         # Create the selection prompt
         prompt = self._create_selection_prompt(current_agent, result, available_agents)
-        
+
         try:
             # Call the LLM
             response = await litellm.acompletion(
@@ -133,30 +132,30 @@ class LLMRoutingComponent(RoutingComponentBase):
                 temperature=self.config.temperature,
                 max_tokens=self.config.max_tokens,
             )
-            
+
             response_content = response.choices[0].message.content.strip()
             logger.debug(f"LLM routing response: {response_content}")
-            
+
             # Parse the JSON response
             try:
                 routing_decision = json.loads(response_content)
                 next_agent = routing_decision.get("next_agent", "")
                 confidence = routing_decision.get("confidence", 0.0)
                 reasoning = routing_decision.get("reasoning", "No reasoning provided")
-                
+
                 logger.info(f"LLM routing decision: {next_agent} (confidence: {confidence}) - {reasoning}")
-                
+
                 # Validate the selected agent is available
                 if next_agent and next_agent not in available_agents and next_agent != "":
                     logger.warning(f"LLM selected unavailable agent '{next_agent}', ending workflow")
                     return "", 0.0
-                
+
                 return next_agent, confidence
-                
+
             except json.JSONDecodeError as e:
                 logger.error(f"Failed to parse LLM response as JSON: {e}")
                 return "", 0.0
-                
+
         except Exception as e:
             logger.error(f"Error calling LLM for routing: {e}")
             return "", 0.0
@@ -168,19 +167,18 @@ class LLMRoutingComponent(RoutingComponentBase):
         context: FlockContext | None = None,
     ) -> None:
         """Use LLM to determine the next agent based on current output."""
-        
         if not context:
             logger.warning("No context provided for LLM routing")
             return
 
         logger.info(f"LLM routing from agent '{agent.name}'")
-        
+
         # Get available agents from context
         agent_definitions = getattr(context, 'agent_definitions', {})
         available_agents = self._get_available_agents(agent_definitions, agent.name)
-        
+
         logger.debug(f"Available agents for LLM routing: {available_agents}")
-        
+
         if not available_agents:
             logger.warning("No available agents for LLM routing")
             return
@@ -189,20 +187,20 @@ class LLMRoutingComponent(RoutingComponentBase):
         next_agent_name, confidence = await self._select_next_agent(
             agent, result, available_agents
         )
-        
+
         logger.info(f"LLM routing result: {next_agent_name} (confidence: {confidence})")
-        
+
         # Check confidence threshold
         if not next_agent_name or confidence < self.config.confidence_threshold:
             logger.warning(
                 f"LLM routing confidence {confidence} below threshold {self.config.confidence_threshold}"
             )
             return
-        
+
         # Validate the selected agent exists
         if next_agent_name not in agent_definitions:
             logger.error(f"LLM selected non-existent agent '{next_agent_name}'")
             return
-        
+
         logger.info(f"Successfully routed to agent '{next_agent_name}' with confidence {confidence}")
         agent.next_agent = next_agent_name

flock/components/utility/memory_utility_component.py

@@ -30,10 +30,10 @@ from flock.adapter.faiss_adapter import FAISSAdapter
 from flock.adapter.pinecone_adapter import PineconeAdapter
 from flock.adapter.vector_base import VectorAdapter
 from flock.core.component.agent_component_base import AgentComponentConfig
-from flock.core.component.utility_component_base import UtilityComponentBase
+from flock.core.component.utility_component import UtilityComponent
 from flock.core.context.context import FlockContext
-from flock.core.registry import flock_component
 from flock.core.logging.logging import get_logger
+from flock.core.registry import flock_component
 
 # Conditional import for MetricsUtilityComponent to avoid circular imports
 if TYPE_CHECKING:
@@ -423,7 +423,7 @@ class MemoryStore:
 
 
 @flock_component(config_class=MemoryUtilityConfig)
-class MemoryUtilityComponent(UtilityComponentBase):
+class MemoryUtilityComponent(UtilityComponent):
     """Enterprise-ready memory utility component using real datastores."""
 
     config: MemoryUtilityConfig = Field(

flock/components/utility/metrics_utility_component.py

@@ -13,10 +13,10 @@ import psutil
 from pydantic import BaseModel, Field, field_validator
 
 from flock.core.component.agent_component_base import AgentComponentConfig
-from flock.core.component.utility_component_base import UtilityComponentBase
+from flock.core.component.utility_component import UtilityComponent
 from flock.core.context.context import FlockContext
+from flock.core.mcp.flock_mcp_server import FlockMCPServer
 from flock.core.registry import flock_component
-from flock.core.mcp.flock_mcp_server import FlockMCPServerBase
 
 if TYPE_CHECKING:
     from flock.core.flock_agent import FlockAgent
@@ -79,7 +79,7 @@ class MetricsUtilityConfig(AgentComponentConfig):
 
 
 @flock_component(config_class=MetricsUtilityConfig)
-class MetricsUtilityComponent(UtilityComponentBase):
+class MetricsUtilityComponent(UtilityComponent):
     """Utility component for collecting and analyzing agent performance metrics."""
 
     # --- Singleton holder for convenient static access ---
@@ -540,7 +540,7 @@ class MetricsUtilityComponent(UtilityComponentBase):
 
     # --- MCP Server Lifecycle Hooks ---
     async def on_server_error(
-        self, server: FlockMCPServerBase, error: Exception
+        self, server: FlockMCPServer, error: Exception
     ) -> None:
         """Record server error metrics."""
         self._record_metric(
@@ -552,7 +552,7 @@ class MetricsUtilityComponent(UtilityComponentBase):
             },
         )
 
-    async def on_pre_server_init(self, server: FlockMCPServerBase):
+    async def on_pre_server_init(self, server: FlockMCPServer):
         """Initialize metrics collection for server."""
         self._server_start_time = time.time()
 
@@ -564,7 +564,7 @@ class MetricsUtilityComponent(UtilityComponentBase):
                 {"server": server.config.name, "phase": "pre_init"},
             )
 
-    async def on_post_server_init(self, server: FlockMCPServerBase):
+    async def on_post_server_init(self, server: FlockMCPServer):
         """Collect metrics after server starts."""
         if self.config.collect_memory:
             checkpoint_memory = psutil.Process().memory_info().rss
@@ -574,7 +574,7 @@ class MetricsUtilityComponent(UtilityComponentBase):
                 {"server": server.config.name, "phase": "post_init"},
             )
 
-    async def on_pre_server_terminate(self, server: FlockMCPServerBase):
+    async def on_pre_server_terminate(self, server: FlockMCPServer):
         """Collect metrics before server terminates."""
         if self.config.collect_memory:
             checkpoint_memory = psutil.Process().memory_info().rss
@@ -584,7 +584,7 @@ class MetricsUtilityComponent(UtilityComponentBase):
                 {"server": server.config.name, "phase": "pre_terminate"},
             )
 
-    async def on_post_server_terminate(self, server: FlockMCPServerBase):
+    async def on_post_server_terminate(self, server: FlockMCPServer):
         """Collect metrics after server terminates.
 
         Clean up and final metric recording.
@@ -615,7 +615,7 @@ class MetricsUtilityComponent(UtilityComponentBase):
                 json.dump(summary, f, indent=2)
 
     async def on_pre_mcp_call(
-        self, server: FlockMCPServerBase, arguments: Any | None = None
+        self, server: FlockMCPServer, arguments: Any | None = None
     ):
         """Record pre-call metrics."""
         if self.config.collect_cpu:
@@ -645,7 +645,7 @@ class MetricsUtilityComponent(UtilityComponentBase):
             )
 
     async def on_post_mcp_call(
-        self, server: FlockMCPServerBase, result: Any | None = None
+        self, server: FlockMCPServer, result: Any | None = None
     ):
         """Record post-call metrics."""
         if self.config.collect_timing and self._server_start_time:
@@ -676,7 +676,7 @@ class MetricsUtilityComponent(UtilityComponentBase):
             )
 
     async def on_connect(
-        self, server: FlockMCPServerBase, additional_params: dict[str, Any]
+        self, server: FlockMCPServer, additional_params: dict[str, Any]
     ) -> dict[str, Any]:
         """Collect metrics during connect."""
         # We should track the refresh rate for clients

flock/components/utility/output_utility_component.py

@@ -7,13 +7,15 @@ from typing import TYPE_CHECKING, Any
 from pydantic import Field
 
 from flock.core.component.agent_component_base import AgentComponentConfig
-from flock.core.component.utility_component_base import UtilityComponentBase
+from flock.core.component.utility_component import UtilityComponent
 from flock.core.context.context import FlockContext
 from flock.core.context.context_vars import FLOCK_BATCH_SILENT_MODE
-from flock.core.registry import flock_component
-from flock.core.logging.formatters.themed_formatter import ThemedAgentResultFormatter
+from flock.core.logging.formatters.themed_formatter import (
+    ThemedAgentResultFormatter,
+)
 from flock.core.logging.formatters.themes import OutputTheme
 from flock.core.logging.logging import get_logger
+from flock.core.registry import flock_component
 
 if TYPE_CHECKING:
     from flock.core.flock_agent import FlockAgent
@@ -58,7 +60,7 @@ class OutputUtilityConfig(AgentComponentConfig):
 
 
 @flock_component(config_class=OutputUtilityConfig)
-class OutputUtilityComponent(UtilityComponentBase):
+class OutputUtilityComponent(UtilityComponent):
     """Utility component that handles output formatting and display."""
 
     config: OutputUtilityConfig = Field(
@@ -97,7 +99,7 @@ class OutputUtilityComponent(UtilityComponentBase):
         """Format a dictionary with proper indentation."""
         if not d:
             return "{}"
-        
+
         items = []
         prefix = "  " * indent
         for key, value in d.items():
@@ -105,17 +107,17 @@ class OutputUtilityComponent(UtilityComponentBase):
                 value = value[:97] + "..."
             formatted_value = self._format_value(value, key)
             items.append(f"{prefix}  {key}: {formatted_value}")
-        
+
         return "{\n" + "\n".join(items) + f"\n{prefix}}}"
 
     def _format_list(self, lst: list[Any]) -> str:
         """Format a list with proper structure."""
         if not lst:
             return "[]"
-        
+
         if len(lst) <= 3:
             return str(lst)
-        
+
         # For longer lists, show first few items and count
         preview = [str(item) for item in lst[:3]]
         return f"[{', '.join(preview)}, ... ({len(lst)} total)]"
@@ -127,7 +129,7 @@ class OutputUtilityComponent(UtilityComponentBase):
             language = match.group(1) or "text"
             code = match.group(2)
             return f"[CODE:{language}]\n{code}\n[/CODE]"
-        
+
         # Replace markdown-style code blocks
         text = re.sub(
             r"```(\w+)?\n(.*?)\n```", replace_code_block, text, flags=re.DOTALL

flock/core/__init__.py

@@ -1,9 +1,22 @@
 """This module contains the core classes of the flock package."""
 
+from flock.core.component import (
+    AgentComponent,
+    AgentComponentConfig,
+    EvaluationComponent,
+    RoutingComponent,
+    UtilityComponent,
+)
 from flock.core.context.context import FlockContext
 from flock.core.flock import Flock
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_factory import FlockFactory
+from flock.core.mcp.flock_mcp_server import (
+    FlockMCPServer,
+)
+from flock.core.mcp.flock_mcp_tool import FlockMCPTool
+from flock.core.mcp.mcp_client import FlockMCPClient
+from flock.core.mcp.mcp_client_manager import FlockMCPClientManager
 from flock.core.registry import (
     RegistryHub as FlockRegistry,  # Keep FlockRegistry name for API compatibility
     flock_callable,
@@ -12,23 +25,24 @@ from flock.core.registry import (
     flock_type,
     get_registry,
 )
-from flock.core.mcp.flock_mcp_server import (
-    FlockMCPServerBase,
-)
-from flock.core.mcp.flock_mcp_tool_base import FlockMCPToolBase
-from flock.core.mcp.mcp_client import FlockMCPClientBase
-from flock.core.mcp.mcp_client_manager import FlockMCPClientManagerBase
 
 __all__ = [
     "Flock",
     "FlockAgent",
     "FlockContext",
     "FlockFactory",
-    "FlockMCPClientBase",
-    "FlockMCPClientManagerBase",
-    "FlockMCPServerBase",
+        # Components
+    "AgentComponent",
+    "AgentComponentConfig",
+    "EvaluationComponent",
+    "RoutingComponent",
+    "UtilityComponent",
+
+    "FlockMCPClient",
+    "FlockMCPClientManager",
+    "FlockMCPServer",
     "FlockMCPServerConfig",
-    "FlockMCPToolBase",
+    "FlockMCPTool",
     "FlockRegistry",
     "flock_callable",
     "flock_component",

flock/core/agent/flock_agent_components.py

@@ -2,14 +2,14 @@
 
 from typing import TYPE_CHECKING, Any
 
-from flock.core.component.evaluation_component_base import EvaluationComponentBase
-from flock.core.component.routing_component_base import RoutingComponentBase
-from flock.core.component.utility_component_base import UtilityComponentBase
+from flock.core.component.evaluation_component import EvaluationComponent
+from flock.core.component.routing_component import RoutingComponent
+from flock.core.component.utility_component import UtilityComponent
 from flock.core.logging.logging import get_logger
 
 if TYPE_CHECKING:
-    from flock.core.flock_agent import FlockAgent
     from flock.core.component.agent_component_base import AgentComponent
+    from flock.core.flock_agent import FlockAgent
 
 logger = get_logger("agent.components")
 
@@ -25,7 +25,7 @@ class FlockAgentComponents:
         if not component.name:
             logger.error("Component must have a name to be added.")
             return
-        
+
         # Check if component with same name already exists
         existing = self.get_component(component.name)
         if existing:
@@ -54,29 +54,29 @@ class FlockAgentComponents:
     def get_enabled_components(self) -> list["AgentComponent"]:
         """Get a list of currently enabled components attached to this agent."""
         return [c for c in self.agent.components if c.config.enabled]
-        
+
     def get_components_by_type(self, component_type: type) -> list["AgentComponent"]:
         """Get all components of a specific type."""
         return [c for c in self.agent.components if isinstance(c, component_type)]
 
-    def get_evaluation_components(self) -> list[EvaluationComponentBase]:
+    def get_evaluation_components(self) -> list[EvaluationComponent]:
         """Get all evaluation components."""
-        return self.get_components_by_type(EvaluationComponentBase)
+        return self.get_components_by_type(EvaluationComponent)
 
-    def get_routing_components(self) -> list[RoutingComponentBase]:
+    def get_routing_components(self) -> list[RoutingComponent]:
         """Get all routing components."""
-        return self.get_components_by_type(RoutingComponentBase)
-        
-    def get_utility_components(self) -> list[UtilityComponentBase]:
+        return self.get_components_by_type(RoutingComponent)
+
+    def get_utility_components(self) -> list[UtilityComponent]:
         """Get all utility components."""
-        return self.get_components_by_type(UtilityComponentBase)
+        return self.get_components_by_type(UtilityComponent)
 
-    def get_primary_evaluator(self) -> EvaluationComponentBase | None:
+    def get_primary_evaluator(self) -> EvaluationComponent | None:
         """Get the primary evaluation component (first one found)."""
         evaluators = self.get_evaluation_components()
         return evaluators[0] if evaluators else None
-        
-    def get_primary_router(self) -> RoutingComponentBase | None:
+
+    def get_primary_router(self) -> RoutingComponent | None:
         """Get the primary routing component (first one found)."""
         routers = self.get_routing_components()
         return routers[0] if routers else None