flock-core 0.4.0b23__tar.gz → 0.4.0b25__tar.gz

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.0b23
+Version: 0.4.0b25
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.4.0b-23"
+version = "0.4.0b-25"
 description = "Declarative LLM Orchestration at Scale"
 readme = "README.md"
 authors = [

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/core/flock.py

@@ -59,6 +59,10 @@ FlockRegistry = get_registry()  # Get the registry instance
 # Define TypeVar for generic class methods like from_dict
 T = TypeVar("T", bound="Flock")
 
+from rich.traceback import install
+
+install(show_locals=True)
+
 
 class Flock(BaseModel, Serializable):
     """Orchestrator for managing and executing agent systems.
@@ -336,6 +340,10 @@ class Flock(BaseModel, Serializable):
                     "No start_agent specified and multiple/no agents exist."
                 )
 
+            # Check if start_agent is in agents
+            if start_agent_name not in self._agents:
+                raise ValueError(f"Start agent '{start_agent_name}' not found.")
+
             run_input = input if input is not None else self._start_input
             effective_run_id = run_id or f"flockrun_{uuid.uuid4().hex[:8]}"
 
@@ -350,9 +358,13 @@ class Flock(BaseModel, Serializable):
             try:
                 resolved_start_agent = self._agents.get(start_agent_name)
                 if not resolved_start_agent:
-                    resolved_start_agent = FlockRegistry.get_agent(start_agent_name)
+                    resolved_start_agent = FlockRegistry.get_agent(
+                        start_agent_name
+                    )
                     if not resolved_start_agent:
-                        raise ValueError(f"Start agent '{start_agent_name}' not found.")
+                        raise ValueError(
+                            f"Start agent '{start_agent_name}' not found."
+                        )
                     self.add_agent(resolved_start_agent)
 
                 run_context = context if context else FlockContext()
@@ -384,15 +396,20 @@ class Flock(BaseModel, Serializable):
 
                 # Execute workflow
                 if not self.enable_temporal:
-                    result = await run_local_workflow(run_context, box_result=False)
+                    result = await run_local_workflow(
+                        run_context, box_result=False
+                    )
                 else:
-                    result = await run_temporal_workflow(run_context, box_result=False)
+                    result = await run_temporal_workflow(
+                        run_context, box_result=False
+                    )
 
                 span.set_attribute("result.type", str(type(result)))
                 result_str = str(result)
                 span.set_attribute(
                     "result.preview",
-                    result_str[:1000] + ("..." if len(result_str) > 1000 else ""),
+                    result_str[:1000]
+                    + ("..." if len(result_str) > 1000 else ""),
                 )
 
                 if box_result:
@@ -400,13 +417,17 @@ class Flock(BaseModel, Serializable):
                         logger.debug("Boxing final result.")
                         return Box(result)
                     except ImportError:
-                        logger.warning("Box library not installed, returning raw dict.")
+                        logger.warning(
+                            "Box library not installed, returning raw dict."
+                        )
                         return result
                 else:
                     return result
 
             except Exception as e:
-                logger.error(f"Flock run '{self.name}' failed: {e}", exc_info=True)
+                logger.error(
+                    f"Flock run '{self.name}' failed: {e}", exc_info=True
+                )
                 span.record_exception(e)
                 span.set_status(trace.Status(trace.StatusCode.ERROR, str(e)))
                 return {

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/core/flock_agent.py

@@ -23,9 +23,9 @@ from rich.console import Console
 
 # Core Flock components (ensure these are importable)
 from flock.core.context.context import FlockContext
-from flock.core.flock_evaluator import FlockEvaluator
-from flock.core.flock_module import FlockModule
-from flock.core.flock_router import FlockRouter
+from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
+from flock.core.flock_module import FlockModule, FlockModuleConfig
+from flock.core.flock_router import FlockRouter, FlockRouterConfig
 from flock.core.logging.logging import get_logger
 
 # Mixins and Serialization components
@@ -45,6 +45,15 @@ tracer = trace.get_tracer(__name__)
 T = TypeVar("T", bound="FlockAgent")
 
 
+SignatureType = (
+    str
+    | Callable[..., str]
+    | type[BaseModel]
+    | Callable[..., type[BaseModel]]
+    | None
+)
+
+
 # Make FlockAgent inherit from Serializable
 class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
     """Core, declarative base class for Flock agents, enabling serialization,
@@ -61,14 +70,14 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
         "",
         description="A human-readable description or a callable returning one.",
     )
-    input: str | Callable[..., str] | None = Field(
+    input: SignatureType = Field(
         None,
         description=(
             "Signature for input keys. Supports type hints (:) and descriptions (|). "
             "E.g., 'query: str | Search query, context: dict | Conversation context'. Can be a callable."
         ),
     )
-    output: str | Callable[..., str] | None = Field(
+    output: SignatureType = Field(
         None,
         description=(
             "Signature for output keys. Supports type hints (:) and descriptions (|). "
@@ -111,6 +120,43 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
         description="Runtime context associated with the flock execution.",
     )
 
+    def __init__(
+        self,
+        name: str,
+        model: str | None = None,
+        description: str | Callable[..., str] | None = "",
+        input: SignatureType = None,
+        output: SignatureType = None,
+        tools: list[Callable[..., Any]] | None = None,
+        evaluator: "FlockEvaluator | None" = None,
+        handoff_router: "FlockRouter | None" = None,
+        modules: dict[str, "FlockModule"] | None = None,  # Use dict for modules
+        write_to_file: bool = False,
+        wait_for_input: bool = False,
+        **kwargs,
+    ):
+        super().__init__(
+            name=name,
+            model=model,
+            description=description,
+            input=input,  # Store the raw input spec
+            output=output,  # Store the raw output spec
+            tools=tools,
+            write_to_file=write_to_file,
+            wait_for_input=wait_for_input,
+            evaluator=evaluator,
+            handoff_router=handoff_router,
+            modules=modules
+            if modules is not None
+            else {},  # Ensure modules is a dict
+            **kwargs,
+        )
+
+        if isinstance(self.input, type) and issubclass(self.input, BaseModel):
+            self._input_model = self.input
+        if isinstance(self.output, type) and issubclass(self.output, BaseModel):
+            self._output_model = self.output
+
     # --- Existing Methods (add_module, remove_module, etc.) ---
     # (Keep these methods as they were, adding type hints where useful)
     def add_module(self, module: FlockModule) -> None:
@@ -359,6 +405,114 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
                 span.record_exception(temporal_error)
                 raise
 
+    def add_component(
+        self,
+        config_instance: FlockModuleConfig
+        | FlockRouterConfig
+        | FlockEvaluatorConfig,
+        component_name: str | None = None,
+    ) -> "FlockAgent":
+        """Adds or replaces a component (Evaluator, Router, Module) based on its configuration object.
+
+        Args:
+            config_instance: An instance of a config class inheriting from
+                             FlockModuleConfig, FlockRouterConfig, or FlockEvaluatorConfig.
+            component_name: Explicit name for the component (required for Modules if not in config).
+
+        Returns:
+            self for potential chaining.
+        """
+        from flock.core.flock_registry import get_registry
+
+        config_type = type(config_instance)
+        registry = get_registry()  # Get registry instance
+        logger.debug(
+            f"Attempting to add component via config: {config_type.__name__}"
+        )
+
+        # --- 1. Find Component Class using Registry Map ---
+        ComponentClass = registry.get_component_class_for_config(config_type)
+
+        if not ComponentClass:
+            logger.error(
+                f"No component class registered for config type {config_type.__name__}. Use @flock_component(config_class=...) on the component."
+            )
+            raise TypeError(
+                f"Cannot find component class for config {config_type.__name__}"
+            )
+
+        component_class_name = ComponentClass.__name__
+        logger.debug(
+            f"Found component class '{component_class_name}' mapped to config '{config_type.__name__}'"
+        )
+
+        # --- 2. Determine Assignment Target and Name (Same as before) ---
+        instance_name = component_name
+        attribute_name: str = ""
+
+        if issubclass(ComponentClass, FlockEvaluator):
+            attribute_name = "evaluator"
+            if not instance_name:
+                instance_name = getattr(
+                    config_instance, "name", component_class_name.lower()
+                )
+
+        elif issubclass(ComponentClass, FlockRouter):
+            attribute_name = "handoff_router"
+            if not instance_name:
+                instance_name = getattr(
+                    config_instance, "name", component_class_name.lower()
+                )
+
+        elif issubclass(ComponentClass, FlockModule):
+            attribute_name = "modules"
+            if not instance_name:
+                instance_name = getattr(
+                    config_instance, "name", component_class_name.lower()
+                )
+            if not instance_name:
+                raise ValueError(
+                    "Module name must be provided either in config or as component_name argument."
+                )
+            # Ensure config has name if module expects it
+            if hasattr(config_instance, "name") and not getattr(
+                config_instance, "name", None
+            ):
+                setattr(config_instance, "name", instance_name)
+
+        else:  # Should be caught by registry map logic ideally
+            raise TypeError(
+                f"Class '{component_class_name}' mapped from config is not a valid Flock component."
+            )
+
+        # --- 3. Instantiate the Component (Same as before) ---
+        try:
+            init_args = {"config": config_instance, "name": instance_name}
+
+            component_instance = ComponentClass(**init_args)
+        except Exception as e:
+            logger.error(
+                f"Failed to instantiate {ComponentClass.__name__} with config {config_type.__name__}: {e}",
+                exc_info=True,
+            )
+            raise RuntimeError(f"Component instantiation failed: {e}") from e
+
+        # --- 4. Assign to the Agent (Same as before) ---
+        if attribute_name == "modules":
+            if not isinstance(self.modules, dict):
+                self.modules = {}
+            self.modules[instance_name] = component_instance
+            logger.info(
+                f"Added/Updated module '{instance_name}' (type: {ComponentClass.__name__}) to agent '{self.name}'"
+            )
+        else:
+            setattr(self, attribute_name, component_instance)
+            logger.info(
+                f"Set {attribute_name} to {ComponentClass.__name__} (instance name: '{instance_name}') for agent '{self.name}'"
+            )
+
+        return self
+
     # resolve_callables remains useful for dynamic definitions
     def resolve_callables(self, context: FlockContext | None = None) -> None:
         """Resolves callable fields (description, input, output) using context."""

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/core/flock_factory.py

@@ -3,7 +3,7 @@
 from collections.abc import Callable
 from typing import Any
 
-from flock.core.flock_agent import FlockAgent
+from flock.core.flock_agent import FlockAgent, SignatureType
 from flock.core.logging.formatters.themes import OutputTheme
 from flock.evaluators.declarative.declarative_evaluator import (
     DeclarativeEvaluator,
@@ -24,8 +24,8 @@ class FlockFactory:
         name: str,
         description: str | Callable[..., str] | None = None,
         model: str | Callable[..., str] | None = None,
-        input: str | Callable[..., str] | None = None,
-        output: str | Callable[..., str] | None = None,
+        input: SignatureType = None,
+        output: SignatureType = None,
         tools: list[Callable[..., Any] | Any] | None = None,
         use_cache: bool = True,
         enable_rich_tables: bool = False,
@@ -42,10 +42,12 @@ class FlockFactory:
     ) -> FlockAgent:
         """Creates a default FlockAgent.
 
-        The default agent includes a declarative evaluator with the following modules:
+        The default agent includes the following modules:
+        - DeclarativeEvaluator
         - OutputModule
+        - MetricsModule
 
-        It also includes often needed configurations like cache usage, rich tables, and output theme.
+        It also includes direct acces to the most important configurations.
         """
         eval_config = DeclarativeEvaluatorConfig(
             model=model,

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/core/flock_registry.py

@@ -32,6 +32,7 @@ if TYPE_CHECKING:
     from flock.core.flock_router import FlockRouter
 
     COMPONENT_BASE_TYPES = (FlockModule, FlockEvaluator, FlockRouter)
+
     IS_COMPONENT_CHECK_ENABLED = True
 else:
     # Define dummy types or skip check if not type checking
@@ -41,12 +42,15 @@ else:
 
 # 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")
 T = TypeVar("T")
 ClassType = TypeVar("ClassType", bound=type)
 FuncType = TypeVar("FuncType", bound=Callable)
+ConfigType = TypeVar("ConfigType", bound=BaseModel)
+_COMPONENT_CONFIG_MAP: dict[type[BaseModel], type[any]] = {}
 
 
 class FlockRegistry:
@@ -105,6 +109,45 @@ class FlockRegistry:
             except Exception as e:
                 logger.error(f"Failed to auto-register core type {t}: {e}")
 
+    @staticmethod
+    def register_config_component_pair(
+        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."
+            )
+        # Add more checks if needed (e.g., component_cls inherits from Module/Router/Evaluator)
+
+        if (
+            config_cls in _COMPONENT_CONFIG_MAP
+            and _COMPONENT_CONFIG_MAP[config_cls] != component_cls
+        ):
+            logger.warning(
+                f"Config class {config_cls.__name__} already mapped to {_COMPONENT_CONFIG_MAP[config_cls].__name__}. Overwriting with {component_cls.__name__}."
+            )
+
+        _COMPONENT_CONFIG_MAP[config_cls] = component_cls
+        logger.debug(
+            f"Registered config mapping: {config_cls.__name__} -> {component_cls.__name__}"
+        )
+
+    @staticmethod
+    def get_component_class_for_config(
+        config_cls: type[ConfigType],
+    ) -> type[ClassType] | None:
+        """Looks up the Component Class associated with a Config Class."""
+        return _COMPONENT_CONFIG_MAP.get(config_cls)
+
     # --- Path String Generation ---
     @staticmethod
     def _get_path_string(obj: Callable | type) -> str | None:
@@ -439,36 +482,41 @@ def get_registry() -> FlockRegistry:
 
 # Type hinting for decorators to preserve signature
 @overload
-def flock_component(cls: ClassType) -> ClassType: ...
+def flock_component(cls: ClassType) -> ClassType: ...  # Basic registration
 @overload
 def flock_component(
-    *, name: str | None = None
-) -> Callable[[ClassType], ClassType]: ...
+    *, name: str | None = None, config_class: type[ConfigType] | None = None
+) -> Callable[[ClassType], ClassType]: ...  # With options
 
 
 def flock_component(
-    cls: ClassType | None = None, *, name: str | None = None
+    cls: ClassType | None = None,
+    *,
+    name: str | None = None,
+    config_class: type[ConfigType] | None = None,
 ) -> Any:
-    """Decorator to register a Flock Component class (Module, Evaluator, Router).
-
-    Usage:
-        @flock_component
-        class MyModule(FlockModule): ...
-
-        @flock_component(name="CustomRouterAlias")
-        class MyRouter(FlockRouter): ...
-    """
+    """Decorator to register a Flock Component class and optionally link its config class."""
     registry = get_registry()
 
     def decorator(inner_cls: ClassType) -> ClassType:
         if not inspect.isclass(inner_cls):
             raise TypeError("@flock_component can only decorate classes.")
+
         component_name = name or inner_cls.__name__
-        registry.register_component(inner_cls, name=component_name)
+        registry.register_component(
+            inner_cls, name=component_name
+        )  # Register component by name
+
+        # If config_class is provided, register the mapping
+        if config_class:
+            FlockRegistry.register_config_component_pair(
+                config_class, inner_cls
+            )
+
         return inner_cls
 
     if cls is None:
-        # Called as @flock_component(name="...")
+        # Called as @flock_component(name="...", config_class=...)
         return decorator
     else:
         # Called as @flock_component

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/evaluators/declarative/declarative_evaluator.py

@@ -7,6 +7,7 @@ from rich.console import Console
 
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
+from flock.core.flock_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
@@ -35,6 +36,7 @@ class DeclarativeEvaluatorConfig(FlockEvaluatorConfig):
     kwargs: dict[str, Any] = Field(default_factory=dict)
 
 
+@flock_component(config_class=DeclarativeEvaluatorConfig)
 class DeclarativeEvaluator(
     FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin
 ):

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/evaluators/memory/memory_evaluator.py

@@ -4,6 +4,7 @@ from pydantic import Field
 
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
+from flock.core.flock_registry import flock_component
 from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
 from flock.core.mixin.prompt_parser import PromptParserMixin
 from flock.modules.memory.memory_module import MemoryModule, MemoryModuleConfig
@@ -45,6 +46,7 @@ class MemoryEvaluatorConfig(FlockEvaluatorConfig):
     )
 
 
+@flock_component(config_class=MemoryEvaluatorConfig)
 class MemoryEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin):
     """Evaluator that uses DSPy for generation."""
 

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/evaluators/test/test_case_evaluator.py

@@ -4,6 +4,7 @@ from pydantic import Field
 
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
+from flock.core.flock_registry import flock_component
 from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
 
 
@@ -13,6 +14,7 @@ class TestCaseEvaluatorConfig(FlockEvaluatorConfig):
     pass
 
 
+@flock_component(config_class=TestCaseEvaluatorConfig)
 class TestCaseEvaluator(FlockEvaluator, DSPyIntegrationMixin):
     """Evaluator for test cases."""
 

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/evaluators/zep/zep_evaluator.py

@@ -4,6 +4,7 @@ from pydantic import Field
 
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
+from flock.core.flock_registry import flock_component
 from flock.core.mixin.dspy_integration import DSPyIntegrationMixin
 from flock.core.mixin.prompt_parser import PromptParserMixin
 from flock.modules.zep.zep_module import ZepModule, ZepModuleConfig
@@ -17,6 +18,7 @@ class ZepEvaluatorConfig(FlockEvaluatorConfig):
     )
 
 
+@flock_component(config_class=ZepEvaluatorConfig)
 class ZepEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin):
     """Evaluator that uses DSPy for generation."""
 

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/modules/assertion/assertion_module.py

@@ -86,7 +86,7 @@ class AssertionModuleConfig(FlockModuleConfig):
     )
 
 
-@flock_component
+@flock_component(config_class=AssertionModuleConfig)
 class AssertionCheckerModule(FlockModule):
     """Checks the output of an agent against a set of defined rules.
 

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/modules/callback/callback_module.py

@@ -7,6 +7,7 @@ from pydantic import Field
 
 from flock.core import FlockModule, FlockModuleConfig
 from flock.core.context.context import FlockContext
+from flock.core.flock_registry import flock_component
 
 
 class CallbackModuleConfig(FlockModuleConfig):
@@ -36,6 +37,7 @@ class CallbackModuleConfig(FlockModuleConfig):
     )
 
 
+@flock_component(config_class=CallbackModuleConfig)
 class CallbackModule(FlockModule):
     """Module that provides callback functionality for agent lifecycle events."""
 

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/modules/memory/memory_module.py

@@ -12,6 +12,7 @@ from flock.core.context.context import FlockContext
 #     from flock.core import FlockAgent
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_module import FlockModule, FlockModuleConfig
+from flock.core.flock_registry import flock_component
 from flock.core.logging.logging import get_logger
 from flock.modules.memory.memory_parser import MemoryMappingParser
 from flock.modules.memory.memory_storage import FlockMemoryStore, MemoryEntry
@@ -59,6 +60,7 @@ class MemoryModuleConfig(FlockModuleConfig):
     )
 
 
+@flock_component(config_class=MemoryModuleConfig)
 class MemoryModule(FlockModule):
     """Module that adds memory capabilities to a Flock agent."""
 

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/modules/output/output_module.py

@@ -5,6 +5,7 @@ from typing import TYPE_CHECKING, Any
 from pydantic import Field
 
 from flock.core.context.context_vars import FLOCK_BATCH_SILENT_MODE
+from flock.core.flock_registry import flock_component
 
 if TYPE_CHECKING:
     from flock.core import FlockAgent
@@ -60,6 +61,7 @@ class OutputModuleConfig(FlockModuleConfig):
     )
 
 
+@flock_component(config_class=OutputModuleConfig)
 class OutputModule(FlockModule):
     """Module that handles output formatting and display."""
 

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/modules/performance/metrics_module.py

@@ -14,6 +14,7 @@ from pydantic import BaseModel, Field, validator
 from flock.core.context.context import FlockContext
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_module import FlockModule, FlockModuleConfig
+from flock.core.flock_registry import flock_component
 
 
 class MetricPoint(BaseModel):
@@ -69,6 +70,7 @@ class MetricsModuleConfig(FlockModuleConfig):
         return v
 
 
+@flock_component(config_class=MetricsModuleConfig)
 class MetricsModule(FlockModule):
     """Module for collecting and analyzing agent performance metrics."""
 

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/modules/zep/zep_module.py

@@ -8,6 +8,7 @@ from zep_python.types import Message as ZepMessage, SessionSearchResult
 from flock.core.context.context import FlockContext
 from flock.core.flock_agent import FlockAgent
 from flock.core.flock_module import FlockModule, FlockModuleConfig
+from flock.core.flock_registry import flock_component
 from flock.core.logging.logging import get_logger
 
 logger = get_logger("module.zep")
@@ -25,6 +26,7 @@ class ZepModuleConfig(FlockModuleConfig):
     enable_write: bool = False
 
 
+@flock_component(config_class=ZepModuleConfig)
 class ZepModule(FlockModule):
     """Module that adds Zep capabilities to a Flock agent."""
 

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/routers/agent/agent_router.py

@@ -4,6 +4,7 @@ from typing import Any
 
 from flock.core.context.context import FlockContext
 from flock.core.flock_agent import FlockAgent
+from flock.core.flock_registry import flock_component
 from flock.core.flock_router import (
     FlockRouter,
     FlockRouterConfig,
@@ -34,6 +35,7 @@ class AgentRouterConfig(FlockRouterConfig):
     confidence_threshold: float = 0.5  # No additional parameters needed for now
 
 
+@flock_component(config_class=AgentRouterConfig)
 class AgentRouter(FlockRouter):
     """Router that uses a FlockAgent to determine the next agent in a workflow.
 

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/routers/conditional/conditional_router.py

@@ -146,7 +146,7 @@ class ConditionalRouterConfig(FlockRouterConfig):
         return self
 
 
-@flock_component
+@flock_component(config_class=ConditionalRouterConfig)
 class ConditionalRouter(FlockRouter):
     """Routes workflow based on evaluating a condition against a value in the FlockContext.
     Supports various built-in checks (string, number, list, type, bool, existence)

{flock_core-0.4.0b23 → flock_core-0.4.0b25}/src/flock/routers/default/default_router.py

@@ -7,6 +7,7 @@ from pydantic import Field
 
 from flock.core.context.context import FlockContext
 from flock.core.flock_agent import FlockAgent
+from flock.core.flock_registry import flock_component
 from flock.core.flock_router import (
     FlockRouter,
     FlockRouterConfig,
@@ -25,6 +26,7 @@ class DefaultRouterConfig(FlockRouterConfig):
     )
 
 
+@flock_component(config_class=DefaultRouterConfig)
 class DefaultRouter(FlockRouter):
     """Default router implementation.