flock-core 0.4.528__py3-none-any.whl → 0.5.0b0__py3-none-any.whl

flock/core/mcp/flock_mcp_server.py

@@ -15,11 +15,11 @@ 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
-from flock.core.mcp.mcp_config import FlockMCPConfigurationBase
+from flock.core.mcp.flock_mcp_tool import FlockMCPTool
+from flock.core.mcp.mcp_client_manager import FlockMCPClientManager
+from flock.core.mcp.mcp_config import FlockMCPConfiguration
 from flock.core.serialization.serializable import Serializable
 from flock.core.serialization.serialization_utils import (
     deserialize_component,
@@ -28,7 +28,7 @@ from flock.core.serialization.serialization_utils import (
 
 logger = get_logger("mcp.server")
 tracer = trace.get_tracer(__name__)
-T = TypeVar("T", bound="FlockMCPServerBase")
+T = TypeVar("T", bound="FlockMCPServer")
 
 LoggingLevel = Literal[
     "debug",
@@ -42,7 +42,7 @@ LoggingLevel = Literal[
 ]
 
 
-class FlockMCPServerBase(BaseModel, Serializable, ABC):
+class FlockMCPServer(BaseModel, Serializable, ABC):
     """Base class for all Flock MCP Server Types.
 
     Servers serve as an abstraction-layer between the underlying MCPClientSession
@@ -64,7 +64,7 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
     2. Using FlockMCPServerConfig.with_fields() to create a config class.
     """
 
-    config: FlockMCPConfigurationBase = Field(
+    config: FlockMCPConfiguration = Field(
         ..., description="Config for clients connecting to the server."
     )
 
@@ -74,15 +74,15 @@ 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 ---
     # (Manages a pool of ClientConnections and does the actual talking to the MCP Server)
     # (Excluded from Serialization)
-    client_manager: FlockMCPClientManagerBase | None = Field(
+    client_manager: FlockMCPClientManager | None = Field(
         default=None,
         exclude=True,
         description="Underlying Connection Manager. Handles the actual underlying connections to the server.",
@@ -98,43 +98,43 @@ 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:
+    async def initialize(self) -> FlockMCPClientManager:
         """Called when initializing the server."""
         pass
 
@@ -211,7 +211,7 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
                         additional_params=additional_params
                     )
                     result: list[
-                        FlockMCPToolBase
+                        FlockMCPTool
                     ] = await self.client_manager.get_tools(
                         agent_id=agent_id,
                         run_id=run_id,
@@ -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(
@@ -385,7 +385,7 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
                 span.record_exception(module_error)
 
     # --- Async Methods ---
-    async def __aenter__(self) -> "FlockMCPServerBase":
+    async def __aenter__(self) -> "FlockMCPServer":
         """Enter the asynchronous context for the server."""
         # Spin up the client-manager
         with tracer.start_as_current_span("server.__aenter__") as span:
@@ -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
 
@@ -614,16 +614,21 @@ class FlockMCPServerBase(BaseModel, Serializable, ABC):
                 config_cls = config_field.annotation
             except (AttributeError, KeyError):
                 # fallback if Pydantic v1 or missing
-                config_cls = FlockMCPConfigurationBase
+                config_cls = FlockMCPConfiguration
             config_object = config_cls.from_dict(config_data)
             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/mcp/{flock_mcp_tool_base.py → flock_mcp_tool.py}

@@ -13,7 +13,7 @@ from flock.core.logging.logging import get_logger
 logger = get_logger("mcp.tool")
 tracer = trace.get_tracer(__name__)
 
-T = TypeVar("T", bound="FlockMCPToolBase")
+T = TypeVar("T", bound="FlockMCPTool")
 
 TYPE_MAPPING = {
     "string": str,
@@ -25,7 +25,7 @@ TYPE_MAPPING = {
 }
 
 
-class FlockMCPToolBase(BaseModel):
+class FlockMCPTool(BaseModel):
     """Base Class for MCP Tools for Flock."""
 
     name: str = Field(..., description="Name of the tool")

flock/core/mcp/mcp_client.py

@@ -37,8 +37,8 @@ from pydantic import (
 )
 
 from flock.core.logging.logging import get_logger
-from flock.core.mcp.flock_mcp_tool_base import FlockMCPToolBase
-from flock.core.mcp.mcp_config import FlockMCPConfigurationBase
+from flock.core.mcp.flock_mcp_tool import FlockMCPTool
+from flock.core.mcp.mcp_config import FlockMCPConfiguration
 from flock.core.mcp.types.factories import (
     default_flock_mcp_list_roots_callback_factory,
     default_flock_mcp_logging_callback_factory,
@@ -61,7 +61,7 @@ tracer = trace.get_tracer(__name__)
 GetSessionIdCallback = Callable[[], str | None]
 
 
-class FlockMCPClientBase(BaseModel, ABC):
+class FlockMCPClient(BaseModel, ABC):
     """Wrapper for mcp ClientSession.
 
     Class will attempt to re-establish connection if possible.
@@ -71,7 +71,7 @@ class FlockMCPClientBase(BaseModel, ABC):
     """
 
     # --- Properties ---
-    config: FlockMCPConfigurationBase = Field(
+    config: FlockMCPConfiguration = Field(
         ..., description="The config for this client instance."
     )
 
@@ -225,7 +225,7 @@ class FlockMCPClientBase(BaseModel, ABC):
 
     def __init__(
         self,
-        config: FlockMCPConfigurationBase,
+        config: FlockMCPConfiguration,
         lock: Lock | None = None,
         tool_cache: TTLCache | None = None,
         tool_result_cache: TTLCache | None = None,
@@ -374,24 +374,24 @@ class FlockMCPClientBase(BaseModel, ABC):
         self,
         agent_id: str,
         run_id: str,
-    ) -> list[FlockMCPToolBase]:
+    ) -> list[FlockMCPTool]:
         """Gets a list of available tools from the server."""
 
         @cached(cache=self.tool_cache, key=cache_key_generator)
         async def _get_tools_cached(
             agent_id: str,
             run_id: str,
-        ) -> list[FlockMCPToolBase]:
+        ) -> list[FlockMCPTool]:
             if not self.config.feature_config.tools_enabled:
                 return []
 
-            async def _get_tools_internal() -> list[FlockMCPToolBase]:
+            async def _get_tools_internal() -> list[FlockMCPTool]:
                 # TODO: Crash
                 response: ListToolsResult = await self.session.list_tools()
                 flock_tools = []
 
                 for tool in response.tools:
-                    converted_tool = FlockMCPToolBase.from_mcp_tool(
+                    converted_tool = FlockMCPTool.from_mcp_tool(
                         tool,
                         agent_id=agent_id,
                         run_id=run_id,

flock/core/mcp/mcp_client_manager.py

@@ -13,22 +13,22 @@ from pydantic import (
 )
 
 from flock.core.logging.logging import get_logger
-from flock.core.mcp.flock_mcp_tool_base import FlockMCPToolBase
+from flock.core.mcp.flock_mcp_tool import FlockMCPTool
 from flock.core.mcp.mcp_client import (
-    FlockMCPClientBase,
+    FlockMCPClient,
 )
-from flock.core.mcp.mcp_config import FlockMCPConfigurationBase
+from flock.core.mcp.mcp_config import FlockMCPConfiguration
 
 logger = get_logger("mcp.client_manager")
 tracer = trace.get_tracer(__name__)
 
-TClient = TypeVar("TClient", bound="FlockMCPClientBase")
+TClient = TypeVar("TClient", bound="FlockMCPClient")
 
 
-class FlockMCPClientManagerBase(BaseModel, ABC, Generic[TClient]):
+class FlockMCPClientManager(BaseModel, ABC, Generic[TClient]):
     """Handles a Pool of MCPClients of type TClient."""
 
-    client_config: FlockMCPConfigurationBase = Field(
+    client_config: FlockMCPConfiguration = Field(
         ..., description="Configuration for clients."
     )
 
@@ -38,7 +38,7 @@ class FlockMCPClientManagerBase(BaseModel, ABC, Generic[TClient]):
         exclude=True,
     )
 
-    clients: dict[str, dict[str, FlockMCPClientBase]] = Field(
+    clients: dict[str, dict[str, FlockMCPClient]] = Field(
         default_factory=dict,
         exclude=True,
         description="Internal Store for the clients.",
@@ -154,7 +154,7 @@ class FlockMCPClientManagerBase(BaseModel, ABC, Generic[TClient]):
         agent_id: str,
         run_id: str,
         additional_params: dict[str, Any] | None = None,
-    ) -> list[FlockMCPToolBase]:
+    ) -> list[FlockMCPTool]:
         """Retrieves a list of tools for the agents to act on."""
         with tracer.start_as_current_span("client_manager.get_tools") as span:
             span.set_attribute("agent_id", agent_id)
@@ -165,7 +165,7 @@ class FlockMCPClientManagerBase(BaseModel, ABC, Generic[TClient]):
                     run_id=run_id,
                     additional_params=additional_params,
                 )
-                tools: list[FlockMCPToolBase] = await client.get_tools(
+                tools: list[FlockMCPTool] = await client.get_tools(
                     agent_id=agent_id, run_id=run_id
                 )
                 return tools

flock/core/mcp/mcp_config.py

@@ -36,14 +36,14 @@ LoggingLevel = Literal[
 ]
 
 
-A = TypeVar("A", bound="FlockMCPCallbackConfigurationBase")
-B = TypeVar("B", bound="FlockMCPConnectionConfigurationBase")
-C = TypeVar("C", bound="FlockMCPConfigurationBase")
-D = TypeVar("D", bound="FlockMCPCachingConfigurationBase")
-E = TypeVar("E", bound="FlockMCPFeatureConfigurationBase")
+A = TypeVar("A", bound="FlockMCPCallbackConfiguration")
+B = TypeVar("B", bound="FlockMCPConnectionConfiguration")
+C = TypeVar("C", bound="FlockMCPConfiguration")
+D = TypeVar("D", bound="FlockMCPCachingConfiguration")
+E = TypeVar("E", bound="FlockMCPFeatureConfiguration")
 
 
-class FlockMCPCachingConfigurationBase(BaseModel, Serializable):
+class FlockMCPCachingConfiguration(BaseModel, Serializable):
     """Configuration for Caching in Clients."""
 
     tool_cache_max_size: float = Field(
@@ -110,7 +110,7 @@ class FlockMCPCachingConfigurationBase(BaseModel, Serializable):
         )
 
 
-class FlockMCPCallbackConfigurationBase(BaseModel, Serializable):
+class FlockMCPCallbackConfiguration(BaseModel, Serializable):
     """Base Configuration Class for Callbacks for Clients."""
 
     sampling_callback: FlockSamplingMCPCallback | None = Field(
@@ -188,7 +188,7 @@ class FlockMCPCallbackConfigurationBase(BaseModel, Serializable):
         )
 
 
-class FlockMCPConnectionConfigurationBase(BaseModel, Serializable):
+class FlockMCPConnectionConfiguration(BaseModel, Serializable):
     """Base Configuration Class for Connection Parameters for a client."""
 
     max_retries: int = Field(
@@ -298,7 +298,7 @@ class FlockMCPConnectionConfigurationBase(BaseModel, Serializable):
         )
 
 
-class FlockMCPFeatureConfigurationBase(BaseModel, Serializable):
+class FlockMCPFeatureConfiguration(BaseModel, Serializable):
     """Base Configuration Class for switching MCP Features on and off."""
 
     roots_enabled: bool = Field(
@@ -346,7 +346,7 @@ class FlockMCPFeatureConfigurationBase(BaseModel, Serializable):
         )
 
 
-class FlockMCPConfigurationBase(BaseModel, Serializable):
+class FlockMCPConfiguration(BaseModel, Serializable):
     """Base Configuration Class for MCP Clients.
 
     Each Client should implement their own config
@@ -357,22 +357,22 @@ class FlockMCPConfigurationBase(BaseModel, Serializable):
         ..., description="Name of the server the client connects to."
     )
 
-    connection_config: FlockMCPConnectionConfigurationBase = Field(
+    connection_config: FlockMCPConnectionConfiguration = Field(
         ..., description="MCP Connection Configuration for a client."
     )
 
-    caching_config: FlockMCPCachingConfigurationBase = Field(
-        default_factory=FlockMCPCachingConfigurationBase,
+    caching_config: FlockMCPCachingConfiguration = Field(
+        default_factory=FlockMCPCachingConfiguration,
         description="Configuration for the internal caches of the client.",
     )
 
-    callback_config: FlockMCPCallbackConfigurationBase = Field(
-        default_factory=FlockMCPCallbackConfigurationBase,
+    callback_config: FlockMCPCallbackConfiguration = Field(
+        default_factory=FlockMCPCallbackConfiguration,
         description="Callback configuration for the client.",
     )
 
-    feature_config: FlockMCPFeatureConfigurationBase = Field(
-        default_factory=FlockMCPFeatureConfigurationBase,
+    feature_config: FlockMCPFeatureConfiguration = Field(
+        default_factory=FlockMCPFeatureConfiguration,
         description="Feature configuration for the client.",
     )
 
@@ -425,7 +425,7 @@ class FlockMCPConfigurationBase(BaseModel, Serializable):
                 config_cls = config_field.annotation
             except (AttributeError, KeyError):
                 # fallback
-                config_cls = FlockMCPConnectionConfigurationBase
+                config_cls = FlockMCPConnectionConfiguration
             instance_data["connection_config"] = config_cls.from_dict(connection_config)
         else:
             raise ValueError(f"connection_config MUST be specified for '{data.get('name', 'unknown_server')}")
@@ -436,10 +436,10 @@ class FlockMCPConfigurationBase(BaseModel, Serializable):
                 config_cls = config_field.annotation
             except (AttributeError, KeyError):
                 # fallback
-                config_cls = FlockMCPCachingConfigurationBase
+                config_cls = FlockMCPCachingConfiguration
             instance_data["caching_config"] = config_cls.from_dict(caching_config)
         else:
-            instance_data["caching_config"] = FlockMCPCachingConfigurationBase()
+            instance_data["caching_config"] = FlockMCPCachingConfiguration()
 
         if feature_config:
             try:
@@ -447,10 +447,10 @@ class FlockMCPConfigurationBase(BaseModel, Serializable):
                 config_cls = config_field.annotation
             except (AttributeError, KeyError):
                 # fallback
-                config_cls = FlockMCPFeatureConfigurationBase
+                config_cls = FlockMCPFeatureConfiguration
             instance_data["feature_config"] = config_cls.from_dict(feature_config)
         else:
-            instance_data["feature_config"] = FlockMCPFeatureConfigurationBase()
+            instance_data["feature_config"] = FlockMCPFeatureConfiguration()
 
         if callback_config:
             try:
@@ -458,10 +458,10 @@ class FlockMCPConfigurationBase(BaseModel, Serializable):
                 config_cls = config_field.annotation
             except (AttributeError, KeyError):
                 # fallback
-                config_cls = FlockMCPCallbackConfigurationBase
+                config_cls = FlockMCPCallbackConfiguration
             instance_data["callback_config"] = config_cls.from_dict(callback_config)
         else:
-            instance_data["callback_config"] = FlockMCPCallbackConfigurationBase()
+            instance_data["callback_config"] = FlockMCPCallbackConfiguration()
 
         return cls(**{k: v for k, v in instance_data.items()})
 

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",
+]