flock-core 0.4.0b23__py3-none-any.whl → 0.4.0b25__py3-none-any.whl

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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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.
 

flock/routers/feedback/feedback_router.py

@@ -35,7 +35,7 @@ class FeedbackRetryRouterConfig(FlockRouterConfig):
     )
 
 
-@flock_component
+@flock_component(config_class=FeedbackRetryRouterConfig)
 class FeedbackRetryRouter(FlockRouter):
     """Routes based on assertion feedback in the context.
 

flock/routers/list_generator/list_generator_router.py

@@ -47,7 +47,7 @@ class IterativeListGeneratorRouterConfig(FlockRouterConfig):
     # item_type_str: Optional[str] = None # e.g., 'dict[str, str]' or 'MyChapterType'
 
 
-@flock_component
+@flock_component(config_class=IterativeListGeneratorRouterConfig)
 class IterativeListGeneratorRouter(FlockRouter):
     name: str = "iterative_list_generator"
     config: IterativeListGeneratorRouterConfig = Field(

flock/routers/llm/llm_router.py

@@ -7,6 +7,7 @@ import litellm
 
 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,
@@ -29,6 +30,7 @@ class LLMRouterConfig(FlockRouterConfig):
     prompt: str = ""
 
 
+@flock_component(config_class=LLMRouterConfig)
 class LLMRouter(FlockRouter):
     """Router that uses an LLM to determine the next agent in a workflow.
 

{flock_core-0.4.0b23.dist-info → flock_core-0.4.0b25.dist-info}/METADATA

@@ -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.dist-info → flock_core-0.4.0b25.dist-info}/RECORD

@@ -19,12 +19,12 @@ flock/cli/view_results.py,sha256=dOzK0O1FHSIDERnx48y-2Xke9BkOHS7pcOhs64AyIg0,781
 flock/cli/yaml_editor.py,sha256=K3N0bh61G1TSDAZDnurqW9e_-hO6CtSQKXQqlDhCjVo,12527
 flock/cli/assets/release_notes.md,sha256=bqnk50jxM3w5uY44Dc7MkdT8XmRREFxrVBAG9XCOSSU,4896
 flock/core/__init__.py,sha256=p7lmQULRu9ejIAELfanZiyMhW0CougIPvyFHW2nqBFQ,847
-flock/core/flock.py,sha256=RcDUc__ukjUy9aSA_n0t8SxXCex4BV_nagTcg22peJ0,25116
-flock/core/flock_agent.py,sha256=Hqh9jh_m-8hc9n9qE34XvTiOx92s7Xu_yR87M0n7GPU,33187
+flock/core/flock.py,sha256=0hKRlG8CRwjq5uicaxxKQCtlD2PP84c1IaO_RxZ-tG0,25666
+flock/core/flock_agent.py,sha256=k2HDMG8yd8It9eZglLA4RDhTHrqq48bE7YEzIayqjq8,39054
 flock/core/flock_evaluator.py,sha256=dOXZeDOGZcAmJ9ahqq_2bdGUU1VOXY4skmwTVpAjiVw,1685
-flock/core/flock_factory.py,sha256=38cq0kovBhjulEecdnNk3MWSklX5lcdg0brhx49ixfQ,2993
+flock/core/flock_factory.py,sha256=uRqcpu1fFbsDKp5YhGk47c6NjC36vAowQ3wzaQqmkBo,2972
 flock/core/flock_module.py,sha256=96aFVYAgwpKN53xGbivQDUpikOYGFCxK5mqhclOcxY0,3003
-flock/core/flock_registry.py,sha256=KjLqJrCpCuvk4Ot5ASbRAWXwy5gHBneS_8IjttRPRnQ,22292
+flock/core/flock_registry.py,sha256=Qcu9juUFNyDAOEsqVxauwVlWdfgKZrSzc8yT8JMiK-c,24246
 flock/core/flock_router.py,sha256=1OAXDsdaIIFApEfo6SRfFEDoTuGt3Si7n2MXiySEfis,2644
 flock/core/api/__init__.py,sha256=OKlhzDWZJfA6ddBwxQUmATY0TSzESsH032u00iVGvdA,228
 flock/core/api/endpoints.py,sha256=qQnJmtcYGkjdKtLllVpyJVjc-iZrvu5EEeVIryyt4tc,12987
@@ -76,34 +76,31 @@ flock/core/util/file_path_utils.py,sha256=Odf7uU32C-x1KNighbNERSiMtkzW4h8laABIoF
 flock/core/util/hydrator.py,sha256=QJvCA8F4nkSP5akp3yg0cT6oaajOr1n7sldW5dCs6Lo,10733
 flock/core/util/input_resolver.py,sha256=ttFiz5L_uzSvxEhWOPL09WfLF--RlLOikLP5hrgE7Mo,6138
 flock/core/util/loader.py,sha256=j3q2qem5bFMP2SmMuYjb-ISxsNGNZd1baQmpvAnRUUk,2244
-flock/evaluators/declarative/declarative_evaluator.py,sha256=gdB1w6_stRhU91D21O9sxqkMbF9VRvaiV6-trwjYLpM,6107
-flock/evaluators/memory/azure_search_evaluator.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flock/evaluators/memory/memory_evaluator.py,sha256=SmerXyNaqm8DTV0yw-WqWkn9DXIf6x-nPG1eyTV6NY8,3452
-flock/evaluators/natural_language/natural_language_evaluator.py,sha256=6nVEeh8_uwv_h-d3FWlA0GbzDzRtdhvxCGKirHtyvOU,2012
-flock/evaluators/test/test_case_evaluator.py,sha256=9vVhYbRrq68TNn8wo9z_yFD4UydhPKlygzy0mDmLLJU,1124
-flock/evaluators/zep/zep_evaluator.py,sha256=9NOELl7JAuUcx_FQrxY6b-_vN3MjwDyW7ZppPIGeCFc,1954
-flock/modules/assertion/assertion_module.py,sha256=f4hUxqB-KsDXJF2FQJ7hIv-0jJZ_g2Sa0scdgozW1Js,12824
-flock/modules/azure-search/azure_search_module.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flock/modules/callback/callback_module.py,sha256=volGGgHtY19qj1wHR6m5a_hmXSbV3Ca3uY6I76YmcfU,2833
-flock/modules/memory/memory_module.py,sha256=bSkdFBW-Pp5ldHhXi8v4kfRM7zknfLR2fsOtbTosucI,14916
+flock/evaluators/declarative/declarative_evaluator.py,sha256=mzg6Ch1JFGZb09goLC3dXxpuojIMR3AcFuoQaIUjEAk,6219
+flock/evaluators/memory/memory_evaluator.py,sha256=ySwz7kcc8suXMJ7gKNSWThW8iOMlE8lUcUzEAHvv8rw,3559
+flock/evaluators/test/test_case_evaluator.py,sha256=3Emcoty0LOLLBIuPGxSpKphuZC9Fu1DTr1vbGg-hd0Q,1233
+flock/evaluators/zep/zep_evaluator.py,sha256=6_5vTdU0yJAH8I8w3-MPXiAZx6iUPhAVCsHjrHzkPLM,2058
+flock/modules/assertion/assertion_module.py,sha256=vzv38E8mvVBQXON_YJ8GFF4kB-sWNychQrMVFmugEjU,12860
+flock/modules/callback/callback_module.py,sha256=q2z-KX7QHlbfDncEP9c_W_DxhYyD6fe9MQfISO9OgrU,2939
+flock/modules/memory/memory_module.py,sha256=MBsUCpnMWY184PlZUKw91b8Yf0jCg9ixsxiqx2tK8LM,15020
 flock/modules/memory/memory_parser.py,sha256=FLH7GL8XThvHiCMfX3eQH7Sz-f62fzhAUmO6_gaDI7U,4372
 flock/modules/memory/memory_storage.py,sha256=CNcLDMmvv0x7Z3YMKr6VveS_VCa7rKPw8l2d-XgqokA,27246
-flock/modules/output/output_module.py,sha256=tpNqkL8cB0cvikr1fmEJ-5E2SAeb-rYhht8IP90mEF0,7281
-flock/modules/performance/metrics_module.py,sha256=UD9OjY4-zAvauMD7YyDYqE1gyIhzpdr3JkBT8j9knxY,16790
-flock/modules/zep/zep_module.py,sha256=x7JG6O6xnwwum0RETIqKYbA3xzdcvX2aUuns0Cl0c2Q,6014
+flock/modules/output/output_module.py,sha256=V2g7UF538dwCe4J2QsemADMOnorGfK5Z995Q2ZIV7K4,7385
+flock/modules/performance/metrics_module.py,sha256=D7MHnkHcGe7BfKFV85LqGujZcXM7Mh95BkSmO7UbJEk,16895
+flock/modules/zep/zep_module.py,sha256=uWhSXma4EIMt70L1_588FLnoLNmU8l7Vhhy1viRK1dk,6115
 flock/platform/docker_tools.py,sha256=fpA7-6rJBjPOUBLdQP4ny2QPgJ_042nmqRn5GtKnoYw,1445
 flock/platform/jaeger_install.py,sha256=MyOMJQx4TQSMYvdUJxfiGSo3YCtsfkbNXcAcQ9bjETA,2898
 flock/routers/__init__.py,sha256=w9uL34Auuo26-q_EGlE8Z9iHsw6S8qutTAH_ZI7pn7M,39
 flock/routers/agent/__init__.py,sha256=0ZOYpR8BMnR5iCGfcUiv99g7aT_g13xvm2Shl-XzybY,65
-flock/routers/agent/agent_router.py,sha256=uSLWlVTGNspp1WZf1rut-58Yxit6ud33aNT3mqbbVJc,8224
+flock/routers/agent/agent_router.py,sha256=d4rberqXguJFmDB_hLTaeaDP_rOvCnVQufPELA-pD6M,8327
 flock/routers/agent/handoff_agent.py,sha256=p-0XEPXIyv1T3DGAhhXg2SYXmrwEaJ5pnuLgRSvbiZg,1903
-flock/routers/conditional/conditional_router.py,sha256=G4zulYBVo4xd6ExJrszmqYa5pyOsE6GXoD5MugNQa78,21223
+flock/routers/conditional/conditional_router.py,sha256=_ETx3GhuS3uYqNz6AYWO0JIPov02l1WqxI7Xq-qyMTY,21261
 flock/routers/default/__init__.py,sha256=DOatGX_aE2DWvf55a0Tv7qDK05QFD-hL3sm7g58hmLU,61
-flock/routers/default/default_router.py,sha256=wKbZFBSL9VhHjm5fzEVMwGkyRtmO3_lfmRnZ02BFeQ8,2279
-flock/routers/feedback/feedback_router.py,sha256=fFHUGnmKBAfdzgIh7EzjHOdEntgTN59JWpc_GsHAawo,4907
-flock/routers/list_generator/list_generator_router.py,sha256=OWnZJNfYCL-V78WxyUNlb8S48xj0-VE59d8XOpppvzk,7692
+flock/routers/default/default_router.py,sha256=RgJm6RcS8ah1S49mM9TccfJpenQ0SzzbPCX0K8ZtnHs,2384
+flock/routers/feedback/feedback_router.py,sha256=RODEmPrrNZ-ODdZ0mGfmO8auEnH6KvHN3f5rmFGeq1M,4947
+flock/routers/list_generator/list_generator_router.py,sha256=mofBBZFSfqek_uiYbiC-6avdfhTF8Q8tyEVka1xxALs,7741
 flock/routers/llm/__init__.py,sha256=OV89ebq8RPWZwCJTS2_P46Q0yKD_03rwq_fBOsETd08,63
-flock/routers/llm/llm_router.py,sha256=k2nxWxkBZaOPByiwUIYjN7N5jcFNAmqhSZm0LcF0tok,12234
+flock/routers/llm/llm_router.py,sha256=F2GAKaiJxWCdtvI1G9vLkoLaY6kR_DgJYoRLenVN9FI,12335
 flock/themes/3024-day.toml,sha256=uOVHqEzSyHx0WlUk3D0lne4RBsNBAPCTy3C58yU7kEY,667
 flock/themes/3024-night.toml,sha256=qsXUwd6ZYz6J-R129_Ao2TKlvvK60svhZJJjB5c8Tfo,1667
 flock/themes/aardvark-blue.toml,sha256=5ZgsxP3pWLPN3yJ2Wd9ErCo7fy_VJpIfje4kriDKlqo,1667
@@ -445,8 +442,8 @@ flock/workflow/activities.py,sha256=Rcgcepa-RzaEjKo2aNuI14O_sX8ij0RrqeyPa0oSw8M,
 flock/workflow/agent_activities.py,sha256=NhBZscflEf2IMfSRa_pBM_TRP7uVEF_O0ROvWZ33eDc,963
 flock/workflow/temporal_setup.py,sha256=VWBgmBgfTBjwM5ruS_dVpA5AVxx6EZ7oFPGw4j3m0l0,1091
 flock/workflow/workflow.py,sha256=I9MryXW_bqYVTHx-nl2epbTqeRy27CAWHHA7ZZA0nAk,1696
-flock_core-0.4.0b23.dist-info/METADATA,sha256=jiZmPSrAwNEiyugjNKF63f0qloquD8CFWb8SWodU588,13004
-flock_core-0.4.0b23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.4.0b23.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.4.0b23.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.4.0b23.dist-info/RECORD,,
+flock_core-0.4.0b25.dist-info/METADATA,sha256=Ph3rXzRZxPyXT03fVs_uebGvo9scAX-Fa_FqN5tAG_U,13004
+flock_core-0.4.0b25.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.4.0b25.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.4.0b25.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.4.0b25.dist-info/RECORD,,

flock/evaluators/natural_language/natural_language_evaluator.py

@@ -1,66 +0,0 @@
-from typing import Any
-
-from flock.core.flock_evaluator import FlockEvaluator
-
-
-class NaturalLanguageEvaluator(FlockEvaluator):
-    """Evaluator that uses natural language prompting."""
-
-    name: str = "natural_language"
-    prompt_template: str = ""
-    client: Any = None  # OpenAI client
-
-    async def setup(self, input_schema: str, output_schema: str) -> None:
-        """Set up prompt template and client."""
-        from openai import AsyncOpenAI
-
-        # Create prompt template
-        self.prompt_template = f"""
-        You are an AI assistant that processes inputs and generates outputs.
-        
-        Input Format:
-        {input_schema}
-        
-        Required Output Format:
-        {output_schema}
-        
-        Please process the following input and provide output in the required format:
-        {{input}}
-        """
-
-        # Set up client
-        self.client = AsyncOpenAI()
-
-    async def evaluate(self, inputs: dict[str, Any]) -> dict[str, Any]:
-        """Evaluate using natural language."""
-        if not self.client:
-            raise RuntimeError("Evaluator not set up")
-
-        # Format input for prompt
-        input_str = "\n".join(f"{k}: {v}" for k, v in inputs.items())
-
-        # Get completion
-        response = await self.client.chat.completions.create(
-            model=self.config.model,
-            messages=[
-                {
-                    "role": "user",
-                    "content": self.prompt_template.format(input=input_str),
-                }
-            ],
-            temperature=self.config.temperature,
-            max_tokens=self.config.max_tokens,
-        )
-
-        # Parse response into dictionary
-        try:
-            import json
-
-            return json.loads(response.choices[0].message.content)
-        except json.JSONDecodeError:
-            return {"result": response.choices[0].message.content}
-
-    async def cleanup(self) -> None:
-        """Close client."""
-        if self.client:
-            await self.client.close()