flock-core 0.4.520__py3-none-any.whl → 0.5.0b2__py3-none-any.whl

flock/core/flock_factory.py

@@ -8,6 +8,13 @@ from typing import Any, Literal
 import httpx
 from pydantic import AnyUrl, BaseModel, ConfigDict, Field, FileUrl
 
+from flock.components.utility.metrics_utility_component import (
+    MetricsUtilityComponent,
+    MetricsUtilityConfig,
+)
+
+# New unified components imported locally to avoid circular imports
+from flock.core.config.flock_agent_config import FlockAgentConfig
 from flock.core.config.scheduled_agent_config import ScheduledAgentConfig
 from flock.core.flock_agent import FlockAgent, SignatureType
 from flock.core.logging.formatters.themes import OutputTheme
@@ -28,10 +35,6 @@ from flock.core.mcp.types.types import (
     StreamableHttpServerParameters,
     WebsocketServerParameters,
 )
-from flock.evaluators.declarative.declarative_evaluator import (
-    DeclarativeEvaluator,
-    DeclarativeEvaluatorConfig,
-)
 from flock.mcp.servers.sse.flock_sse_server import (
     FlockSSEConfig,
     FlockSSEConnectionConfig,
@@ -52,11 +55,6 @@ from flock.mcp.servers.websockets.flock_websocket_server import (
     FlockWSConnectionConfig,
     FlockWSServer,
 )
-from flock.modules.output.output_module import OutputModule, OutputModuleConfig
-from flock.modules.performance.metrics_module import (
-    MetricsModule,
-    MetricsModuleConfig,
-)
 from flock.workflow.temporal_config import TemporalActivityConfig
 
 LoggingLevel = Literal[
@@ -111,34 +109,29 @@ class FlockFactory:
     class StreamableHttpParams(BaseModel):
         """Factory-Params for Streamable Http Servers."""
 
-        url: str | AnyUrl = Field(
-            ...,
-            description="Url the server listens at."
-        )
+        url: str | AnyUrl = Field(..., description="Url the server listens at.")
 
         headers: dict[str, Any] | None = Field(
             default=None,
-            description="Additional Headers to pass to the client."
+            description="Additional Headers to pass to the client.",
         )
 
         auth: httpx.Auth | None = Field(
-            default=None,
-            description="Httpx Auth Schema."
+            default=None, description="Httpx Auth Schema."
         )
 
         timeout_seconds: float | int = Field(
-            default=5,
-            description="Http Timeout in Seconds"
+            default=5, description="Http Timeout in Seconds"
         )
 
         sse_read_timeout_seconds: float | int = Field(
-            default=60*5,
-            description="How many seconds to wait for server-sent events until closing the connection."
+            default=60 * 5,
+            description="How many seconds to wait for server-sent events until closing the connection.",
         )
 
         terminate_on_close: bool = Field(
             default=True,
-            description="Whether or not to terminate the underlying connection on close."
+            description="Whether or not to terminate the underlying connection on close.",
         )
 
         model_config = ConfigDict(
@@ -169,8 +162,7 @@ class FlockFactory:
         )
 
         auth: httpx.Auth | None = Field(
-            default=None,
-            description="Httpx Auth Scheme."
+            default=None, description="Httpx Auth Scheme."
         )
 
         model_config = ConfigDict(
@@ -189,7 +181,10 @@ class FlockFactory:
     @staticmethod
     def create_mcp_server(
         name: str,
-        connection_params: StreamableHttpParams | SSEParams | StdioParams | WebsocketParams,
+        connection_params: StreamableHttpParams
+        | SSEParams
+        | StdioParams
+        | WebsocketParams,
         max_retries: int = 3,
         mount_points: list[str | MCPRoot] | None = None,
         timeout_seconds: int | float = 10,
@@ -380,13 +375,13 @@ class FlockFactory:
 
         server = concrete_server_cls(config=server_config)
 
-        metrics_module_config = MetricsModuleConfig(
+        metrics_component_config = MetricsUtilityConfig(
             latency_threshold_ms=alert_latency_threshold_ms
         )
 
-        metrics_module = MetricsModule("metrics", config=metrics_module_config)
+        metrics_component = MetricsUtilityComponent("metrics", config=metrics_component_config)
 
-        server.add_module(metrics_module)
+        server.add_component(metrics_component)
 
         return server
 
@@ -415,16 +410,31 @@ class FlockFactory:
         include_thought_process: bool = False,
         temporal_activity_config: TemporalActivityConfig | None = None,
     ) -> FlockAgent:
-        """Creates a default FlockAgent.
+        """Creates a default FlockAgent using unified component architecture.
 
-        The default agent includes the following modules:
-        - DeclarativeEvaluator
-        - OutputModule
-        - MetricsModule
+        The default agent includes the following unified components:
+        - DeclarativeEvaluationComponent (core LLM evaluation)
+        - OutputUtilityComponent (result formatting and display)
+        - MetricsUtilityComponent (performance tracking)
 
-        It also includes direct acces to the most important configurations.
+        This provides a complete, production-ready agent with sensible defaults.
         """
-        eval_config = DeclarativeEvaluatorConfig(
+        # Import unified components locally to avoid circular imports
+        from flock.components.evaluation.declarative_evaluation_component import (
+            DeclarativeEvaluationComponent,
+            DeclarativeEvaluationConfig,
+        )
+        from flock.components.utility.metrics_utility_component import (
+            MetricsUtilityComponent,
+            MetricsUtilityConfig,
+        )
+        from flock.components.utility.output_utility_component import (
+            OutputUtilityComponent,
+            OutputUtilityConfig,
+        )
+
+        # Create evaluation component
+        eval_config = DeclarativeEvaluationConfig(
             model=model,
             use_cache=use_cache,
             max_tokens=max_tokens,
@@ -434,8 +444,30 @@ class FlockFactory:
             stream=stream,
             include_thought_process=include_thought_process,
         )
+        evaluator = DeclarativeEvaluationComponent(
+            name="default_evaluator", config=eval_config
+        )
+
+        # Create output utility component
+        output_config = OutputUtilityConfig(
+            render_table=enable_rich_tables,
+            theme=output_theme,
+            no_output=no_output,
+            print_context=print_context,
+        )
+        output_component = OutputUtilityComponent(
+            name="output_formatter", config=output_config
+        )
 
-        evaluator = DeclarativeEvaluator(name="default", config=eval_config)
+        # Create metrics utility component
+        metrics_config = MetricsUtilityConfig(
+            latency_threshold_ms=alert_latency_threshold_ms
+        )
+        metrics_component = MetricsUtilityComponent(
+            name="metrics_tracker", config=metrics_config
+        )
+
+        # Create agent with unified components
         agent = FlockAgent(
             name=name,
             input=input,
@@ -444,65 +476,54 @@ class FlockFactory:
             servers=servers,
             model=model,
             description=description,
-            evaluator=evaluator,
-            write_to_file=write_to_file,
-            wait_for_input=wait_for_input,
+            components=[evaluator, output_component, metrics_component],
+            config=FlockAgentConfig(write_to_file=write_to_file,
+                                    wait_for_input=wait_for_input),
+            next_agent=None,  # No next agent by default
             temporal_activity_config=temporal_activity_config,
         )
-        output_config = OutputModuleConfig(
-            render_table=enable_rich_tables,
-            theme=output_theme,
-            no_output=no_output,
-            print_context=print_context,
-        )
-        output_module = OutputModule("output", config=output_config)
-
-        metrics_config = MetricsModuleConfig(
-            latency_threshold_ms=alert_latency_threshold_ms
-        )
-        metrics_module = MetricsModule("metrics", config=metrics_config)
 
-        agent.add_module(output_module)
-        agent.add_module(metrics_module)
         return agent
 
     @staticmethod
     def create_scheduled_agent(
         name: str,
-        schedule_expression: str, # e.g., "every 1h", "0 0 * * *"
+        schedule_expression: str,  # e.g., "every 1h", "0 0 * * *"
         description: str | Callable[..., str] | None = None,
         model: str | Callable[..., str] | None = None,
-        output: SignatureType = None, # Input might be implicit or none
+        output: SignatureType = None,  # Input might be implicit or none
         tools: list[Callable[..., Any] | Any] | None = None,
         servers: list[str | FlockMCPServerBase] | None = None,
-        use_cache: bool = False, # Whether to cache results
-        temperature: float = 0.7, # Temperature for model responses
+        use_cache: bool = False,  # Whether to cache results
+        temperature: float = 0.7,  # Temperature for model responses
         # ... other common agent params from create_default_agent ...
-        temporal_activity_config: TemporalActivityConfig | None = None, # If you want scheduled tasks to be Temporal activities
-        **kwargs # Forward other standard agent params
+        temporal_activity_config: TemporalActivityConfig
+        | None = None,  # If you want scheduled tasks to be Temporal activities
+        **kwargs,  # Forward other standard agent params
     ) -> FlockAgent:
         """Creates a FlockAgent configured to run on a schedule."""
-        agent_config = ScheduledAgentConfig( # Use the new config type
+        agent_config = ScheduledAgentConfig(  # Use the new config type
             schedule_expression=schedule_expression,
             enabled=True,
             initial_run=True,
             max_runs=0,
-            **kwargs
+            **kwargs,
         )
 
-
-        agent = FlockFactory.create_default_agent( # Reuse your existing factory
-            name=name,
-            description=description,
-            model=model,
-            input="trigger_time: str | Time of scheduled execution",
-            output=output,
-            tools=tools,
-            servers=servers,
-            temporal_activity_config=temporal_activity_config,
-            use_cache=use_cache,
-            temperature=temperature,
-            **kwargs
+        agent = (
+            FlockFactory.create_default_agent(  # Reuse your existing factory
+                name=name,
+                description=description,
+                model=model,
+                input="trigger_time: str | Time of scheduled execution",
+                output=output,
+                tools=tools,
+                servers=servers,
+                temporal_activity_config=temporal_activity_config,
+                use_cache=use_cache,
+                temperature=temperature,
+                **kwargs,
+            )
         )
         agent.config = agent_config  # Assign the scheduled agent config
 

flock/core/{flock_registry.py → flock_registry.py.backup}

@@ -29,12 +29,10 @@ if TYPE_CHECKING:
     from flock.core.flock_agent import (
         FlockAgent,  # Import only for type checking
     )
-    from flock.core.flock_evaluator import FlockEvaluator
-    from flock.core.flock_module import FlockModule
-    from flock.core.flock_router import FlockRouter
     from flock.core.mcp.flock_mcp_server import FlockMCPServerBase
+    from flock.core.component.agent_component_base import AgentComponent
 
-    COMPONENT_BASE_TYPES = (FlockModule, FlockEvaluator, FlockRouter)
+    COMPONENT_BASE_TYPES = (AgentComponent,)
 
     IS_COMPONENT_CHECK_ENABLED = True
 else:
@@ -44,7 +42,6 @@ else:
     IS_COMPONENT_CHECK_ENABLED = False
 
 # Fallback if core types aren't available during setup
-from flock.core.flock_module import FlockModuleConfig
 from flock.core.logging.logging import get_logger
 
 logger = get_logger("registry")
@@ -118,18 +115,7 @@ class FlockRegistry:
         config_cls: type[ConfigType], component_cls: type[ClassType]
     ):
         """Explicitly registers the mapping between a config and component class."""
-        from flock.core.flock_evaluator import (
-            FlockEvaluatorConfig,
-        )
-        from flock.core.flock_router import FlockRouterConfig
-
-        if not issubclass(
-            config_cls,
-            FlockModuleConfig | FlockRouterConfig | FlockEvaluatorConfig,
-        ):
-            logger.warning(
-                f"Config class {config_cls.__name__} does not inherit from a standard Flock config base."
-            )
+        # Component config validation can be added here if needed
         # Add more checks if needed (e.g., component_cls inherits from Module/Router/Evaluator)
 
         if (

flock/core/logging/logging.py

@@ -154,6 +154,7 @@ def color_for_category(category: str) -> str:
     if category in COLOR_MAP:
         return COLOR_MAP[category]
     parts = category.split(".")
+    # Try progressively shorter parent categories
     for i in range(len(parts) - 1, 0, -1):
         parent_category = ".".join(parts[:i])
         if parent_category in COLOR_MAP:

flock/core/mcp/flock_mcp_server.py

@@ -15,7 +15,7 @@ from pydantic import (
     Field,
 )
 
-from flock.core.flock_module import FlockModule
+from flock.core.component.agent_component_base import AgentComponent
 from flock.core.logging.logging import get_logger
 from flock.core.mcp.flock_mcp_tool_base import FlockMCPToolBase
 from flock.core.mcp.mcp_client_manager import FlockMCPClientManagerBase
@@ -74,9 +74,9 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
         description="Whether or not this Server has already initialized.",
     )
 
-    modules: dict[str, FlockModule] = Field(
+    components: dict[str, AgentComponent] = Field(
         default={},
-        description="Dictionary of FlockModules attached to this Server.",
+        description="Dictionary of unified agent components attached to this Server.",
     )
 
     # --- Underlying ConnectionManager ---
@@ -98,40 +98,40 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
         arbitrary_types_allowed=True,
     )
 
-    def add_module(self, module: FlockModule) -> None:
-        """Add a module to this server."""
-        if not module.name:
-            logger.error("Module must have a name to be added.")
+    def add_component(self, component: AgentComponent) -> None:
+        """Add a unified component to this server."""
+        if not component.name:
+            logger.error("Component must have a name to be added.")
             return
-        if self.modules and module.name in self.modules:
-            logger.warning(f"Overwriting existing module: {module.name}")
+        if self.components and component.name in self.components:
+            logger.warning(f"Overwriting existing component: {component.name}")
 
-        self.modules[module.name] = module
+        self.components[component.name] = component
         logger.debug(
-            f"Added module '{module.name}' to server {self.config.name}"
+            f"Added component '{component.name}' to server {self.config.name}"
         )
         return
 
-    def remove_module(self, module_name: str) -> None:
-        """Remove a module from this server."""
-        if module_name in self.modules:
-            del self.modules[module_name]
+    def remove_component(self, component_name: str) -> None:
+        """Remove a component from this server."""
+        if component_name in self.components:
+            del self.components[component_name]
             logger.debug(
-                f"Removed module '{module_name}' from server '{self.config.name}'"
+                f"Removed component '{component_name}' from server '{self.config.name}'"
             )
         else:
             logger.warning(
-                f"Module '{module_name}' not found on server '{self.config.name}'"
+                f"Component '{component_name}' not found on server '{self.config.name}'"
             )
         return
 
-    def get_module(self, module_name: str) -> FlockModule | None:
-        """Get a module by name."""
-        return self.modules.get(module_name)
+    def get_component(self, component_name: str) -> AgentComponent | None:
+        """Get a component by name."""
+        return self.components.get(component_name)
 
-    def get_enabled_modules(self) -> list[FlockModule]:
-        """Get a list of currently enabled modules attached to this server."""
-        return [m for m in self.modules.values() if m.config.enabled]
+    def get_enabled_components(self) -> list[AgentComponent]:
+        """Get a list of currently enabled components attached to this server."""
+        return [c for c in self.components.values() if c.config.enabled]
 
     @abstractmethod
     async def initialize(self) -> FlockMCPClientManagerBase:
@@ -244,7 +244,7 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
             try:
                 if not additional_params:
                     additional_params = {}
-                for module in self.get_enabled_modules():
+                for module in self.get_enabled_components():
                     additional_params = await module.on_connect(
                         server=self, additional_params=additional_params
                     )
@@ -264,7 +264,7 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
         with tracer.start_as_current_span("server.pre_init") as span:
             span.set_attribute("server.name", self.config.name)
             try:
-                for module in self.get_enabled_modules():
+                for module in self.get_enabled_components():
                     await module.on_pre_server_init(self)
             except Exception as module_error:
                 logger.error(
@@ -282,7 +282,7 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
         with tracer.start_as_current_span("server.post_init") as span:
             span.set_attribute("server.name", self.config.name)
             try:
-                for module in self.get_enabled_modules():
+                for module in self.get_enabled_components():
                     await module.on_post_server_init(self)
             except Exception as module_error:
                 logger.error(
@@ -300,7 +300,7 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
         with tracer.start_as_current_span("server.pre_terminate") as span:
             span.set_attribute("server.name", self.config.name)
             try:
-                for module in self.get_enabled_modules():
+                for module in self.get_enabled_components():
                     await module.on_pre_server_terminate(self)
             except Exception as module_error:
                 logger.error(
@@ -318,7 +318,7 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
         with tracer.start_as_current_span("server.post_terminate") as span:
             span.set_attribute("server.name", self.config.name)
             try:
-                for module in self.get_enabled_modules():
+                for module in self.get_enabled_components():
                     await module.on_post_server_terminate(server=self)
             except Exception as module_error:
                 logger.error(
@@ -336,7 +336,7 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
         with tracer.start_as_current_span("server.on_error") as span:
             span.set_attribute("server.name", self.config.name)
             try:
-                for module in self.get_enabled_modules():
+                for module in self.get_enabled_components():
                     await module.on_server_error(server=self, error=error)
             except Exception as module_error:
                 logger.error(
@@ -354,7 +354,7 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
         with tracer.start_as_current_span("server.pre_mcp_call") as span:
             span.set_attribute("server.name", self.config.name)
             try:
-                for module in self.get_enabled_modules():
+                for module in self.get_enabled_components():
                     await module.on_pre_mcp_call(
                         server=self, arguments=arguments
                     )
@@ -374,7 +374,7 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
         with tracer.start_as_current_span("server.post_mcp_call") as span:
             span.set_attribute("server.name", self.config.name)
             try:
-                for module in self.get_enabled_modules():
+                for module in self.get_enabled_components():
                     await module.on_post_mcp_call(server=self, result=result)
             except Exception as module_error:
                 logger.error(
@@ -432,9 +432,9 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
     # --- Serialization Implementation ---
     def to_dict(self, path_type: str = "relative") -> dict[str, Any]:
         """Convert instance to dictionary representation suitable for serialization."""
-        from flock.core.flock_registry import get_registry
+        from flock.core.registry import get_registry
 
-        FlockRegistry = get_registry()
+        registry = get_registry()
 
         exclude = ["modules", "config"]
 
@@ -498,7 +498,7 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
         def add_serialized_component(component: Any, field_name: str):
             if component:
                 comp_type = type(component)
-                type_name = FlockRegistry.get_component_type_name(
+                type_name = registry.get_component_type_name(
                     comp_type
                 )  # Get registered name
 
@@ -619,11 +619,16 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
             data["config"] = config_object
 
         # now construct
-        server = real_cls(**{k: v for k, v in data.items() if k != "modules"})
+        server = real_cls(**{k: v for k, v in data.items() if k not in ["modules", "components"]})
 
-        # re-hydrate modules
+        # re-hydrate components (both legacy modules and new components)
+        for cname, cdata in data.get("components", {}).items():
+            server.add_component(deserialize_component(cdata, AgentComponent))
+
+        # Handle legacy modules for backward compatibility during transition
         for mname, mdata in data.get("modules", {}).items():
-            server.add_module(deserialize_component(mdata, FlockModule))
+            logger.warning(f"Legacy module '{mname}' found during deserialization - consider migrating to unified components")
+            # Skip legacy modules during migration
 
         # --- Separate Data ---
         component_configs = {}

flock/core/mixin/dspy_integration.py

@@ -30,9 +30,9 @@ def _resolve_type_string(type_str: str) -> type:
     List, Dict, Optional, Union, Literal.
     """
     # Import registry here to avoid circular imports
-    from flock.core.flock_registry import get_registry
+    from flock.core.registry import get_registry
 
-    FlockRegistry = get_registry()
+    registry = get_registry()
 
     type_str = type_str.strip()
     logger.debug(f"Attempting to resolve type string: '{type_str}'")
@@ -40,7 +40,7 @@ def _resolve_type_string(type_str: str) -> type:
     # 1. Check built-ins and registered types directly
     try:
         # This covers str, int, bool, Any, and types registered by name
-        resolved_type = FlockRegistry.get_type(type_str)
+        resolved_type = registry.get_type(type_str)
         logger.debug(f"Resolved '{type_str}' via registry to: {resolved_type}")
         return resolved_type
     except KeyError:
@@ -61,7 +61,7 @@ def _resolve_type_string(type_str: str) -> type:
 
         try:
             # Get the base generic type (e.g., list, dict, Optional) from registry/builtins
-            BaseType = FlockRegistry.get_type(
+            BaseType = registry.get_type(
                 base_name
             )  # Expects List, Dict etc. to be registered
             logger.debug(
@@ -149,7 +149,7 @@ class DSPyIntegrationMixin:
         self, agent_name, description_spec, fields_spec
     ) -> Any:
         """Creates a dynamic DSPy Signature class from string specifications,
-        resolving types using the FlockRegistry.
+        resolving types using the registry.
         """
         try:
             import dspy

flock/core/orchestration/__init__.py

@@ -0,0 +1,18 @@
+# src/flock/core/orchestration/__init__.py
+"""Orchestration components for Flock."""
+
+from .flock_batch_processor import FlockBatchProcessor
+from .flock_evaluator import FlockEvaluator
+from .flock_execution import FlockExecution
+from .flock_initialization import FlockInitialization
+from .flock_server_manager import FlockServerManager
+from .flock_web_server import FlockWebServer
+
+__all__ = [
+    "FlockExecution",
+    "FlockServerManager", 
+    "FlockBatchProcessor",
+    "FlockEvaluator",
+    "FlockWebServer",
+    "FlockInitialization",
+]