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

flock/core/flock_agent.py

@@ -428,81 +428,71 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
             exclude_none=True,  # Exclude None values for cleaner output
         )
         logger.debug(f"Base agent data for '{self.name}': {list(data.keys())}")
+        serialized_modules = {}
+
+        def add_serialized_component(component: Any, field_name: str):
+            if component:
+                comp_type = type(component)
+                type_name = FlockRegistry.get_component_type_name(
+                    comp_type
+                )  # Get registered name
+                if type_name:
+                    try:
+                        serialized_component_data = serialize_item(component)
+
+                        if not isinstance(serialized_component_data, dict):
+                            logger.error(
+                                f"Serialization of component {type_name} for field '{field_name}' did not result in a dictionary. Got: {type(serialized_component_data)}"
+                            )
+                            serialized_modules[field_name] = {
+                                "type": type_name,
+                                "name": getattr(component, "name", "unknown"),
+                                "error": "serialization_failed_non_dict",
+                            }
+                        else:
+                            serialized_component_data["type"] = type_name
+                            serialized_modules[field_name] = (
+                                serialized_component_data
+                            )
+                            logger.debug(
+                                f"Successfully serialized component for field '{field_name}' (type: {type_name})"
+                            )
 
-        # --- Serialize Components using Registry Type Names ---
-        # Evaluator
-        if self.evaluator:
-            logger.debug(f"Serializing evaluator for agent '{self.name}'")
-            evaluator_type_name = FlockRegistry.get_component_type_name(
-                type(self.evaluator)
-            )
-            if evaluator_type_name:
-                # Recursively serialize the evaluator's dict representation
-                evaluator_dict = serialize_item(
-                    self.evaluator.model_dump(mode="json", exclude_none=True)
-                )
-                evaluator_dict["type"] = evaluator_type_name  # Add type marker
-                data["evaluator"] = evaluator_dict
-                logger.debug(
-                    f"Added evaluator of type '{evaluator_type_name}' to agent '{self.name}'"
-                )
-            else:
-                logger.warning(
-                    f"Could not get registered type name for evaluator {type(self.evaluator).__name__} in agent '{self.name}'. Skipping serialization."
-                )
-
-        # Router
-        if self.handoff_router:
-            logger.debug(f"Serializing router for agent '{self.name}'")
-            router_type_name = FlockRegistry.get_component_type_name(
-                type(self.handoff_router)
-            )
-            if router_type_name:
-                router_dict = serialize_item(
-                    self.handoff_router.model_dump(
-                        mode="json", exclude_none=True
-                    )
-                )
-                router_dict["type"] = router_type_name
-                data["handoff_router"] = router_dict
-                logger.debug(
-                    f"Added router of type '{router_type_name}' to agent '{self.name}'"
-                )
-            else:
-                logger.warning(
-                    f"Could not get registered type name for router {type(self.handoff_router).__name__} in agent '{self.name}'. Skipping serialization."
-                )
-
-        # Modules
-        if self.modules:
-            logger.debug(
-                f"Serializing {len(self.modules)} modules for agent '{self.name}'"
-            )
-            serialized_modules = {}
-            for name, module_instance in self.modules.items():
-                module_type_name = FlockRegistry.get_component_type_name(
-                    type(module_instance)
-                )
-                if module_type_name:
-                    module_dict = serialize_item(
-                        module_instance.model_dump(
-                            mode="json", exclude_none=True
+                    except Exception as e:
+                        logger.error(
+                            f"Failed to serialize component {type_name} for field '{field_name}': {e}",
+                            exc_info=True,
                         )
-                    )
-                    module_dict["type"] = module_type_name
-                    serialized_modules[name] = module_dict
-                    logger.debug(
-                        f"Added module '{name}' of type '{module_type_name}' to agent '{self.name}'"
-                    )
+                        serialized_modules[field_name] = {
+                            "type": type_name,
+                            "name": getattr(component, "name", "unknown"),
+                            "error": "serialization_failed",
+                        }
                 else:
                     logger.warning(
-                        f"Could not get registered type name for module {type(module_instance).__name__} ('{name}') in agent '{self.name}'. Skipping."
+                        f"Cannot serialize unregistered component {comp_type.__name__} for field '{field_name}'"
                     )
-            if serialized_modules:
-                data["modules"] = serialized_modules
-                logger.debug(
-                    f"Added {len(serialized_modules)} modules to agent '{self.name}'"
-                )
+
+        add_serialized_component(self.evaluator, "evaluator")
+        if serialized_modules:
+            data["evaluator"] = serialized_modules["evaluator"]
+            logger.debug(f"Added evaluator to agent '{self.name}'")
+
+        serialized_modules = {}
+        add_serialized_component(self.handoff_router, "handoff_router")
+        if serialized_modules:
+            data["handoff_router"] = serialized_modules["handoff_router"]
+            logger.debug(f"Added handoff_router to agent '{self.name}'")
+
+        serialized_modules = {}
+        for module in self.modules.values():
+            add_serialized_component(module, module.name)
+
+        if serialized_modules:
+            data["modules"] = serialized_modules
+            logger.debug(
+                f"Added {len(serialized_modules)} modules to agent '{self.name}'"
+            )
 
         # --- Serialize Tools (Callables) ---
         if self.tools:

flock/core/flock_factory.py

@@ -32,7 +32,7 @@ class FlockFactory:
         output_theme: OutputTheme = OutputTheme.abernathy,
         wait_for_input: bool = False,
         temperature: float = 0.0,
-        max_tokens: int = 4096,
+        max_tokens: int = 8192,
         alert_latency_threshold_ms: int = 30000,
         no_output: bool = False,
         print_context: bool = False,

flock/core/flock_registry.py

@@ -5,6 +5,7 @@ within the Flock framework to support dynamic lookup and serialization.
 
 from __future__ import annotations  # Add this at the very top
 
+import builtins
 import importlib
 import inspect
 import sys
@@ -172,57 +173,88 @@ class FlockRegistry:
         )
         return None
 
-    def get_callable(self, path_str: str) -> Callable:
-        """Retrieves a callable by its path string, attempting dynamic import if not found."""
-        if path_str in self._callables:
-            logger.debug(f"Found callable '{path_str}' in registry")
-            return self._callables[path_str]
+    def get_callable(self, name_or_path: str) -> Callable:
+        """Retrieves a callable by its registered name or full path string.
+        Attempts dynamic import if not found directly. Prioritizes exact match,
+        then searches for matches ending with '.{name}'.
+        """
+        # 1. Try exact match first (covers full paths and simple names if registered that way)
+        if name_or_path in self._callables:
+            logger.debug(
+                f"Found callable '{name_or_path}' directly in registry."
+            )
+            return self._callables[name_or_path]
+
+        # 2. If not found, and it looks like a simple name, search registered paths
+        if "." not in name_or_path:
+            matches = []
+            for path_str, func in self._callables.items():
+                # Check if path ends with ".{simple_name}" or exactly matches simple_name
+                if path_str == name_or_path or path_str.endswith(
+                    f".{name_or_path}"
+                ):
+                    matches.append(func)
 
-        logger.debug(
-            f"Callable '{path_str}' not in registry, attempting dynamic import."
-        )
-        try:
-            if "." not in path_str:  # Built-ins
-                logger.debug(f"Trying to import built-in callable '{path_str}'")
-                builtins_module = importlib.import_module("builtins")
-                if hasattr(builtins_module, path_str):
-                    func = getattr(builtins_module, path_str)
-                    if callable(func):
-                        self.register_callable(func, path_str)  # Cache it
-                        logger.info(
-                            f"Successfully imported built-in callable '{path_str}'"
-                        )
-                        return func
-                logger.error(f"Built-in callable '{path_str}' not found.")
-                raise KeyError(f"Built-in callable '{path_str}' not found.")
-
-            logger.debug(f"Trying to import module callable '{path_str}'")
-            module_name, func_name = path_str.rsplit(".", 1)
-            module = importlib.import_module(module_name)
-            func = getattr(module, func_name)
-            if callable(func):
-                self.register_callable(
-                    func, path_str
-                )  # Cache dynamically imported
-                logger.info(
-                    f"Successfully imported module callable '{path_str}'"
+            if len(matches) == 1:
+                logger.debug(
+                    f"Found unique callable for simple name '{name_or_path}' via path '{self.get_callable_path_string(matches[0])}'."
                 )
-                return func
-            else:
+                return matches[0]
+            elif len(matches) > 1:
+                # Ambiguous simple name - require full path
+                found_paths = [
+                    self.get_callable_path_string(f) for f in matches
+                ]
                 logger.error(
-                    f"Dynamically imported object '{path_str}' is not callable."
+                    f"Ambiguous callable name '{name_or_path}'. Found matches: {found_paths}. Use full path string for lookup."
                 )
-                raise TypeError(
-                    f"Dynamically imported object '{path_str}' is not callable."
+                raise KeyError(
+                    f"Ambiguous callable name '{name_or_path}'. Use full path string."
                 )
-        except (ImportError, AttributeError, KeyError, TypeError) as e:
-            logger.error(
-                f"Failed to dynamically load/find callable '{path_str}': {e}",
-                exc_info=True,
+            # else: Not found by simple name search in registry, proceed to dynamic import
+
+        # 3. Attempt dynamic import if it looks like a full path
+        if "." in name_or_path:
+            logger.debug(
+                f"Callable '{name_or_path}' not in registry cache, attempting dynamic import."
             )
-            raise KeyError(
-                f"Callable '{path_str}' not found or failed to load: {e}"
-            ) from e
+            try:
+                module_name, func_name = name_or_path.rsplit(".", 1)
+                module = importlib.import_module(module_name)
+                func = getattr(module, func_name)
+                if callable(func):
+                    self.register_callable(
+                        func, name_or_path
+                    )  # Cache dynamically imported
+                    logger.info(
+                        f"Successfully imported and registered module callable '{name_or_path}'"
+                    )
+                    return func
+                else:
+                    raise TypeError(
+                        f"Dynamically imported object '{name_or_path}' is not callable."
+                    )
+            except (ImportError, AttributeError, TypeError) as e:
+                logger.error(
+                    f"Failed to dynamically load/find callable '{name_or_path}': {e}",
+                    exc_info=False,
+                )
+                # Fall through to raise KeyError
+        # 4. Handle built-ins if not found yet (might be redundant if simple name check worked)
+        elif name_or_path in builtins.__dict__:
+            func = builtins.__dict__[name_or_path]
+            if callable(func):
+                self.register_callable(func, name_or_path)  # Cache it
+                logger.info(
+                    f"Found and registered built-in callable '{name_or_path}'"
+                )
+                return func
+
+        # 5. Final failure
+        logger.error(
+            f"Callable '{name_or_path}' not found in registry or via import."
+        )
+        raise KeyError(f"Callable '{name_or_path}' not found.")
 
     def get_callable_path_string(self, func: Callable) -> str | None:
         """Gets the path string for a callable, registering it if necessary."""

flock/core/flock_router.py

@@ -14,13 +14,26 @@ class HandOffRequest(BaseModel):
     next_agent: str = Field(default="", description="Next agent to invoke")
     # match = use the output fields of the current agent that also exists as input field of the next agent
     # add = add the output of the current agent to the input of the next agent
-    hand_off_mode: Literal["match", "add"] = Field(default="match")
+    output_to_input_merge_strategy: Literal["match", "add"] = Field(
+        default="match"
+    )
+    add_input_fields: list[str] | None = Field(
+        default=None,
+        description="List of input fields to add to the next agent",
+    )
+    add_output_fields: list[str] | None = Field(
+        default=None,
+        description="List of output fields to add to the next agent",
+    )
+    add_description: str | None = Field(
+        default=None, description="Add this description to the next agent"
+    )
     override_next_agent: Any | None = Field(
         default=None,
         description="Override the next agent to hand off to",
     )
     override_context: FlockContext | None = Field(
-        default=None, descrio="Override context parameters"
+        default=None, description="Override context parameters"
     )
 
 
@@ -34,10 +47,10 @@ class FlockRouterConfig(BaseModel):
     enabled: bool = Field(
         default=True, description="Whether the router is enabled"
     )
-    agents: list[str] | None = Field(
-        default=None,
-        description="List of agents to choose from",
-    )
+    # agents: list[str] | None = Field(
+    #     default=None,
+    #     description="List of agents to choose from",
+    # )
 
 
 class FlockRouter(BaseModel, ABC):

flock/core/mixin/dspy_integration.py

@@ -408,7 +408,7 @@ class DSPyIntegrationMixin:
 
             lm = dspy.settings.get("lm")
             cost = sum([x["cost"] for x in lm.history if x["cost"] is not None])
-            lm_history = lm.inspect_history()
+            lm_history = lm.history
 
             return final_result, cost, lm_history
 

flock/core/serialization/serialization_utils.py

@@ -8,6 +8,7 @@ import sys
 import types
 import typing
 from collections.abc import Mapping, Sequence
+from enum import Enum
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -57,7 +58,9 @@ def _format_type_to_string(type_hint: type) -> str:
             inner_type = next(t for t in args if t is not type(None))
             return _format_type_to_string(inner_type)
         # return f"Optional[{_format_type_to_string(inner_type)}]"
-        return f"Union[{', '.join(_format_type_to_string(arg) for arg in args)}]"
+        return (
+            f"Union[{', '.join(_format_type_to_string(arg) for arg in args)}]"
+        )
     elif origin is Literal:
         formatted_args = []
         for arg in args:
@@ -66,7 +69,9 @@ def _format_type_to_string(type_hint: type) -> str:
             else:
                 formatted_args.append(str(arg))
         return f"Literal[{', '.join(formatted_args)}]"
-    elif hasattr(type_hint, "__forward_arg__"):  # Handle ForwardRefs if necessary
+    elif hasattr(
+        type_hint, "__forward_arg__"
+    ):  # Handle ForwardRefs if necessary
         return type_hint.__forward_arg__
     elif hasattr(type_hint, "__name__"):
         # Handle custom types registered in registry (get preferred name)
@@ -83,7 +88,9 @@ def _format_type_to_string(type_hint: type) -> str:
         type_repr = str(type_hint).replace("typing.", "")  # Basic cleanup
         type_repr = str(type_hint).replace("| None", "")
         type_repr = type_repr.strip()
-        logger.debug(f"Using fallback string representation for type: {type_repr}")
+        logger.debug(
+            f"Using fallback string representation for type: {type_repr}"
+        )
         return type_repr
 
 
@@ -189,18 +196,51 @@ def serialize_item(item: Any) -> Any:
 
     FlockRegistry = get_registry()
 
-    if isinstance(item, BaseModel):
-        dumped = item.model_dump(mode="json", exclude_none=True)
-        return serialize_item(dumped)
-    elif callable(item) and not isinstance(item, type):
-        path_str = FlockRegistry.get_callable_path_string(item)  # Use registry helper
+    if callable(item) and not isinstance(item, type):
+        path_str = FlockRegistry.get_callable_path_string(
+            item
+        )  # Use registry helper
         if path_str:
-            return {"__callable_ref__": path_str}
+            # Store the simple name (last part of the path) for cleaner YAML/JSON
+            simple_name = path_str.split(".")[-1]
+            logger.debug(
+                f"Serializing callable '{getattr(item, '__name__', 'unknown')}' as reference: '{simple_name}' (from path '{path_str}')"
+            )
+            return {
+                "__callable_ref__": simple_name
+            }  # Use simple name convention
         else:
+            # Handle unregistered callables (e.g., lambdas defined inline)
+            # Option 1: Raise error (stricter)
+            # raise ValueError(f"Cannot serialize unregistered callable: {getattr(item, '__name__', item)}")
+            # Option 2: Store string representation with warning (more lenient)
             logger.warning(
-                f"Could not get path string for callable {item}, storing as string."
+                f"Cannot serialize unregistered callable {getattr(item, '__name__', item)}, storing as string."
             )
             return str(item)
+    elif isinstance(item, BaseModel):
+        logger.debug(
+            f"Serializing Pydantic model instance: {item.__class__.__name__}"
+        )
+        serialized_dict = {}
+        # Iterate through defined fields in the model
+        fields_to_iterate = {}
+        if hasattr(item, "model_fields"):  # Pydantic v2
+            fields_to_iterate = item.model_fields
+
+        for field_name in fields_to_iterate:
+            # Get the value *from the instance*
+            try:
+                value = getattr(item, field_name)
+                if value is not None:  # Exclude None values
+                    # Recursively serialize the field's value
+                    serialized_dict[field_name] = serialize_item(value)
+            except AttributeError:
+                # Should not happen if iterating model_fields/__fields__ but handle defensively
+                logger.warning(
+                    f"Attribute '{field_name}' not found on instance of {item.__class__.__name__} during serialization."
+                )
+        return serialized_dict
     elif isinstance(item, Mapping):
         return {key: serialize_item(value) for key, value in item.items()}
     elif isinstance(item, Sequence) and not isinstance(item, str):
@@ -218,8 +258,12 @@ def serialize_item(item: Any) -> Any:
         )  # Check regular types/classes by path
         if type_name:
             return {"__type_ref__": type_name}
-        logger.warning(f"Could not serialize type object {item}, storing as string.")
+        logger.warning(
+            f"Could not serialize type object {item}, storing as string."
+        )
         return str(item)
+    elif isinstance(item, Enum):
+        return item.value
     else:
         # Return basic types as is
         return item
@@ -240,12 +284,24 @@ def deserialize_item(item: Any) -> Any:
 
     if isinstance(item, Mapping):
         if "__callable_ref__" in item and len(item) == 1:
-            path_str = item["__callable_ref__"]
+            ref_name = item["__callable_ref__"]
             try:
-                return FlockRegistry.get_callable(path_str)
+                # The registry's get_callable needs to handle lookup by simple name OR full path
+                # Or we assume get_callable handles finding the right function from the simple name
+                resolved_callable = FlockRegistry.get_callable(ref_name)
+                logger.debug(
+                    f"Deserialized callable reference '{ref_name}' to {resolved_callable}"
+                )
+                return resolved_callable
             except KeyError:
                 logger.error(
-                    f"Callable reference '{path_str}' not found during deserialization."
+                    f"Callable reference '{ref_name}' not found during deserialization."
+                )
+                return None  # Or raise?
+            except Exception as e:
+                logger.error(
+                    f"Error resolving callable reference '{ref_name}': {e}",
+                    exc_info=True,
                 )
                 return None
         elif "__component_ref__" in item and len(item) == 1:
@@ -273,7 +329,9 @@ def deserialize_item(item: Any) -> Any:
                         mod = importlib.import_module(module_name)
                     type_obj = getattr(mod, class_name)
                     if isinstance(type_obj, type):
-                        FlockRegistry.register_type(type_obj, type_name)  # Cache it
+                        FlockRegistry.register_type(
+                            type_obj, type_name
+                        )  # Cache it
                         return type_obj
                     else:
                         raise TypeError()
@@ -294,7 +352,9 @@ def deserialize_item(item: Any) -> Any:
 
 
 # --- Component Deserialization Helper ---
-def deserialize_component(data: dict | None, expected_base_type: type) -> Any | None:
+def deserialize_component(
+    data: dict | None, expected_base_type: type
+) -> Any | None:
     """Deserializes a component (Module, Evaluator, Router) from its dict representation.
     Uses the 'type' field to find the correct class via FlockRegistry.
     """
@@ -306,10 +366,14 @@ def deserialize_component(data: dict | None, expected_base_type: type) -> Any |
     if data is None:
         return None
     if not isinstance(data, dict):
-        logger.error(f"Expected dict for component deserialization, got {type(data)}")
+        logger.error(
+            f"Expected dict for component deserialization, got {type(data)}"
+        )
         return None
 
-    type_name = data.get("type")  # Assuming 'type' key holds the class name string
+    type_name = data.get(
+        "type"
+    )  # Assuming 'type' key holds the class name string
     if not type_name:
         logger.error(f"Component data missing 'type' field: {data}")
         return None
@@ -317,7 +381,9 @@ def deserialize_component(data: dict | None, expected_base_type: type) -> Any |
     try:
         ComponentClass = FlockRegistry.get_component(type_name)  # Use registry
         # Optional: Keep the base type check
-        if COMPONENT_BASE_TYPES and not issubclass(ComponentClass, expected_base_type):
+        if COMPONENT_BASE_TYPES and not issubclass(
+            ComponentClass, expected_base_type
+        ):
             raise TypeError(
                 f"Deserialized class {type_name} is not a subclass of {expected_base_type.__name__}"
             )

flock/core/util/input_resolver.py

@@ -152,6 +152,11 @@ def resolve_inputs(
                 continue
 
             # Fallback to the initial input
+            var_value = context.get_variable(key)
+            if var_value is not None:
+                inputs[key] = var_value
+                continue
+
             inputs[key] = context.get_variable("flock." + key)
 
         # Case 2: A compound key (e.g., "agent_name.property" or "context.property")

flock/evaluators/declarative/declarative_evaluator.py

@@ -2,7 +2,7 @@ from collections.abc import Generator
 from typing import Any
 
 import dspy
-from pydantic import Field
+from pydantic import Field, PrivateAttr
 from rich.console import Console
 
 from flock.core.flock_agent import FlockAgent
@@ -35,7 +35,9 @@ class DeclarativeEvaluatorConfig(FlockEvaluatorConfig):
     kwargs: dict[str, Any] = Field(default_factory=dict)
 
 
-class DeclarativeEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin):
+class DeclarativeEvaluator(
+    FlockEvaluator, DSPyIntegrationMixin, PromptParserMixin
+):
     """Evaluator that uses DSPy for generation."""
 
     config: DeclarativeEvaluatorConfig = Field(
@@ -43,8 +45,8 @@ class DeclarativeEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMix
         description="Evaluator configuration",
     )
 
-    cost: float = 0.0
-    lm_history: list = Field(default_factory=list)
+    _cost: float = PrivateAttr(default=0.0)
+    _lm_history: list = PrivateAttr(default_factory=list)
 
     async def evaluate(
         self, agent: FlockAgent, inputs: dict[str, Any], tools: list[Any]
@@ -89,10 +91,14 @@ class DeclarativeEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMix
 
         # --- Conditional Evaluation (Stream vs No Stream) ---
         if self.config.stream:
-            logger.info(f"Evaluating agent '{agent.name}' with async streaming.")
+            logger.info(
+                f"Evaluating agent '{agent.name}' with async streaming."
+            )
             if not callable(agent_task):
                 logger.error("agent_task is not callable, cannot stream.")
-                raise TypeError("DSPy task could not be created or is not callable.")
+                raise TypeError(
+                    "DSPy task could not be created or is not callable."
+                )
 
             streaming_task = dspy.streamify(agent_task)
             stream_generator: Generator = streaming_task(**inputs)
@@ -112,9 +118,11 @@ class DeclarativeEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMix
                 if delta_content:
                     console.print(delta_content, end="")
 
-                result_dict, cost, lm_history = self._process_result(chunk, inputs)
-                self.cost = cost
-                self.lm_history = lm_history
+                result_dict, cost, lm_history = self._process_result(
+                    chunk, inputs
+                )
+                self._cost = cost
+                self._lm_history = lm_history
 
             console.print("\n")
             return self.filter_thought_process(
@@ -126,9 +134,11 @@ class DeclarativeEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMix
             try:
                 # Ensure the call is awaited if the underlying task is async
                 result_obj = agent_task(**inputs)
-                result_dict, cost, lm_history = self._process_result(result_obj, inputs)
-                self.cost = cost
-                self.lm_history = lm_history
+                result_dict, cost, lm_history = self._process_result(
+                    result_obj, inputs
+                )
+                self._cost = cost
+                self._lm_history = lm_history
                 return self.filter_thought_process(
                     result_dict, self.config.include_thought_process
                 )
@@ -140,7 +150,7 @@ class DeclarativeEvaluator(FlockEvaluator, DSPyIntegrationMixin, PromptParserMix
                 raise RuntimeError(f"Evaluation failed: {e}") from e
 
     def filter_thought_process(
-        result_dict: dict[str, Any], include_thought_process: bool
+        self, result_dict: dict[str, Any], include_thought_process: bool
     ) -> dict[str, Any]:
         """Filter out thought process from the result dictionary."""
         if include_thought_process: