flock-core 0.3.41__py3-none-any.whl → 0.4.0b2__py3-none-any.whl

flock/core/flock_agent.py

@@ -374,10 +374,12 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
             mode="json",  # Use json mode for better handling of standard types by Pydantic
             exclude_none=True,  # Exclude None values for cleaner output
         )
+        logger.debug(f"Base agent data for '{self.name}': {list(data.keys())}")
 
         # --- 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)
             )
@@ -388,6 +390,9 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
                 )
                 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."
@@ -395,6 +400,7 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
 
         # 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)
             )
@@ -406,6 +412,9 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
                 )
                 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."
@@ -413,6 +422,9 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
 
         # 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(
@@ -426,32 +438,55 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
                     )
                     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}'"
+                    )
                 else:
                     logger.warning(
                         f"Could not get registered type name for module {type(module_instance).__name__} ('{name}') in agent '{self.name}'. Skipping."
                     )
             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:
+            logger.debug(
+                f"Serializing {len(self.tools)} tools for agent '{self.name}'"
+            )
             serialized_tools = []
             for tool in self.tools:
                 if callable(tool) and not isinstance(tool, type):
                     path_str = FlockRegistry.get_callable_path_string(tool)
                     if path_str:
-                        serialized_tools.append({"__callable_ref__": path_str})
+                        # Get just the function name from the path string
+                        # If it's a namespaced path like module.submodule.function_name
+                        # Just use the function_name part
+                        func_name = path_str.split(".")[-1]
+                        serialized_tools.append(func_name)
+                        logger.debug(
+                            f"Added tool '{func_name}' (from path '{path_str}') to agent '{self.name}'"
+                        )
                     else:
                         logger.warning(
                             f"Could not get path string for tool {tool} in agent '{self.name}'. Skipping."
                         )
-                # Silently skip non-callable items or log warning
-                # else:
-                #      logger.warning(f"Non-callable item found in tools list for agent '{self.name}': {tool}. Skipping.")
+                else:
+                    logger.warning(
+                        f"Non-callable item found in tools list for agent '{self.name}': {tool}. Skipping."
+                    )
             if serialized_tools:
                 data["tools"] = serialized_tools
+                logger.debug(
+                    f"Added {len(serialized_tools)} tools to agent '{self.name}'"
+                )
 
         # No need to call _filter_none_values here as model_dump(exclude_none=True) handles it
+        logger.info(
+            f"Serialization of agent '{self.name}' complete with {len(data)} fields"
+        )
         return data
 
     @classmethod
@@ -466,6 +501,7 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
             raise ValueError("Agent data must include a 'name' field.")
         FlockRegistry = get_registry()
         agent_name = data["name"]  # For logging context
+        logger.info(f"Deserializing agent '{agent_name}'")
 
         # Pop complex components to handle them after basic agent instantiation
         evaluator_data = data.pop("evaluator", None)
@@ -473,6 +509,10 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
         modules_data = data.pop("modules", {})
         tools_data = data.pop("tools", [])
 
+        logger.debug(
+            f"Agent '{agent_name}' has {len(modules_data)} modules and {len(tools_data)} tools"
+        )
+
         # Deserialize remaining data recursively (handles nested basic types/callables)
         # Note: Pydantic v2 handles most basic deserialization well if types match.
         # Explicit deserialize_item might be needed if complex non-pydantic structures exist.
@@ -481,6 +521,9 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
 
         try:
             # Create the agent instance using Pydantic's constructor
+            logger.debug(
+                f"Creating agent instance with fields: {list(deserialized_basic_data.keys())}"
+            )
             agent = cls(**deserialized_basic_data)
         except Exception as e:
             logger.error(
@@ -495,13 +538,16 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
         # Evaluator
         if evaluator_data:
             try:
+                logger.debug(
+                    f"Deserializing evaluator for agent '{agent_name}'"
+                )
                 agent.evaluator = deserialize_component(
                     evaluator_data, FlockEvaluator
                 )
                 if agent.evaluator is None:
                     raise ValueError("deserialize_component returned None")
                 logger.debug(
-                    f"Deserialized evaluator '{agent.evaluator.name}' for agent '{agent_name}'"
+                    f"Deserialized evaluator '{agent.evaluator.name}' of type '{evaluator_data.get('type')}' for agent '{agent_name}'"
                 )
             except Exception as e:
                 logger.error(
@@ -514,13 +560,14 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
         # Router
         if router_data:
             try:
+                logger.debug(f"Deserializing router for agent '{agent_name}'")
                 agent.handoff_router = deserialize_component(
                     router_data, FlockRouter
                 )
                 if agent.handoff_router is None:
                     raise ValueError("deserialize_component returned None")
                 logger.debug(
-                    f"Deserialized router '{agent.handoff_router.name}' for agent '{agent_name}'"
+                    f"Deserialized router '{agent.handoff_router.name}' of type '{router_data.get('type')}' for agent '{agent_name}'"
                 )
             except Exception as e:
                 logger.error(
@@ -532,8 +579,14 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
         # Modules
         if modules_data:
             agent.modules = {}  # Ensure it's initialized
+            logger.debug(
+                f"Deserializing {len(modules_data)} modules for agent '{agent_name}'"
+            )
             for name, module_data in modules_data.items():
                 try:
+                    logger.debug(
+                        f"Deserializing module '{name}' of type '{module_data.get('type')}' for agent '{agent_name}'"
+                    )
                     module_instance = deserialize_component(
                         module_data, FlockModule
                     )
@@ -543,6 +596,9 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
                         agent.add_module(
                             module_instance
                         )  # Use add_module for consistency
+                        logger.debug(
+                            f"Successfully added module '{name}' to agent '{agent_name}'"
+                        )
                     else:
                         raise ValueError("deserialize_component returned None")
                 except Exception as e:
@@ -555,25 +611,61 @@ class FlockAgent(BaseModel, Serializable, DSPyIntegrationMixin, ABC):
         # --- Deserialize Tools ---
         agent.tools = []  # Initialize tools list
         if tools_data:
-            for tool_ref in tools_data:
-                if (
-                    isinstance(tool_ref, dict)
-                    and "__callable_ref__" in tool_ref
-                ):
-                    path_str = tool_ref["__callable_ref__"]
-                    try:
-                        tool_func = FlockRegistry.get_callable(path_str)
-                        agent.tools.append(tool_func)
-                    except KeyError:
-                        logger.error(
-                            f"Tool callable '{path_str}' not found in registry for agent '{agent_name}'. Skipping."
+            # Get component registry to look up function imports
+            registry = get_registry()
+            components = getattr(registry, "_callables", {})
+            logger.debug(
+                f"Deserializing {len(tools_data)} tools for agent '{agent_name}'"
+            )
+            logger.debug(
+                f"Available callables in registry: {list(components.keys())}"
+            )
+
+            for tool_name in tools_data:
+                try:
+                    logger.debug(f"Looking for tool '{tool_name}' in registry")
+                    # First try to lookup by simple name in the registry's callables
+                    found = False
+                    for path_str, func in components.items():
+                        if (
+                            path_str.endswith("." + tool_name)
+                            or path_str == tool_name
+                        ):
+                            agent.tools.append(func)
+                            found = True
+                            logger.info(
+                                f"Found tool '{tool_name}' via path '{path_str}' for agent '{agent_name}'"
+                            )
+                            break
+
+                    # If not found by simple name, try manual import
+                    if not found:
+                        logger.debug(
+                            f"Attempting to import tool '{tool_name}' from modules"
                         )
-                else:
-                    logger.warning(
-                        f"Invalid tool format found during deserialization for agent '{agent_name}': {tool_ref}. Skipping."
+                        # Check in relevant modules (could be customized based on project structure)
+                        import __main__
+
+                        if hasattr(__main__, tool_name):
+                            agent.tools.append(getattr(__main__, tool_name))
+                            found = True
+                            logger.info(
+                                f"Found tool '{tool_name}' in __main__ module for agent '{agent_name}'"
+                            )
+
+                    if not found:
+                        logger.warning(
+                            f"Could not find tool '{tool_name}' for agent '{agent_name}'"
+                        )
+                except Exception as e:
+                    logger.error(
+                        f"Error adding tool '{tool_name}' to agent '{agent_name}': {e}",
+                        exc_info=True,
                     )
 
-        logger.info(f"Successfully deserialized agent: {agent.name}")
+        logger.info(
+            f"Successfully deserialized agent '{agent_name}' with {len(agent.modules)} modules and {len(agent.tools)} tools"
+        )
         return agent
 
     # --- Pydantic v2 Configuration ---

flock/core/flock_registry.py

@@ -162,16 +162,20 @@ class FlockRegistry:
                 and self._callables[path_str] != func
             ):
                 logger.warning(
-                    f"Callable '{path_str}' already registered. Overwriting."
+                    f"Callable '{path_str}' already registered with a different function. Overwriting."
                 )
             self._callables[path_str] = func
-            logger.debug(f"Registered callable: {path_str}")
+            logger.debug(f"Registered callable: '{path_str}' ({func.__name__})")
             return path_str
+        logger.warning(
+            f"Could not register callable {func.__name__}: Unable to determine path string"
+        )
         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]
 
         logger.debug(
@@ -179,14 +183,20 @@ class FlockRegistry:
         )
         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)
@@ -194,14 +204,21 @@ class FlockRegistry:
                 self.register_callable(
                     func, path_str
                 )  # Cache dynamically imported
+                logger.info(
+                    f"Successfully imported module callable '{path_str}'"
+                )
                 return func
             else:
+                logger.error(
+                    f"Dynamically imported object '{path_str}' is not callable."
+                )
                 raise TypeError(
                     f"Dynamically imported object '{path_str}' is not callable."
                 )
         except (ImportError, AttributeError, KeyError, TypeError) as e:
             logger.error(
-                f"Failed to dynamically load/find callable '{path_str}': {e}"
+                f"Failed to dynamically load/find callable '{path_str}': {e}",
+                exc_info=True,
             )
             raise KeyError(
                 f"Callable '{path_str}' not found or failed to load: {e}"
@@ -209,11 +226,26 @@ class FlockRegistry:
 
     def get_callable_path_string(self, func: Callable) -> str | None:
         """Gets the path string for a callable, registering it if necessary."""
+        # First try to find by direct identity
         for path_str, registered_func in self._callables.items():
             if func == registered_func:
+                logger.debug(
+                    f"Found existing path string for callable: '{path_str}'"
+                )
                 return path_str
+
         # If not found by identity, generate path, register, and return
-        return self.register_callable(func)
+        path_str = self.register_callable(func)
+        if path_str:
+            logger.debug(
+                f"Generated and registered new path string for callable: '{path_str}'"
+            )
+        else:
+            logger.warning(
+                f"Failed to generate path string for callable {func.__name__}"
+            )
+
+        return path_str
 
     # --- Type Registration ---
     def register_type(
@@ -227,7 +259,7 @@ class FlockRegistry:
                     f"Type '{type_name}' already registered. Overwriting."
                 )
             self._types[type_name] = type_obj
-            # logger.debug(f"Registered type: {type_name}")
+            logger.debug(f"Registered type: {type_name}")
             return type_name
         return None
 

flock/core/serialization/serializable.py

@@ -2,7 +2,7 @@
 import json
 from abc import ABC, abstractmethod
 from pathlib import Path
-from typing import Any, TypeVar
+from typing import Any, Literal, TypeVar
 
 # Use yaml if available, otherwise skip yaml methods
 try:
@@ -85,16 +85,32 @@ class Serializable(ABC):
             ) from e
 
     # --- YAML Methods ---
-    def to_yaml(self, sort_keys=False, default_flow_style=False) -> str:
-        """Serialize to YAML string."""
+    def to_yaml(
+        self,
+        path_type: Literal["absolute", "relative"] = "relative",
+        sort_keys=False,
+        default_flow_style=False,
+    ) -> str:
+        """Serialize to YAML string.
+
+        Args:
+            path_type: How file paths should be formatted ('absolute' or 'relative')
+            sort_keys: Whether to sort dictionary keys
+            default_flow_style: YAML flow style setting
+        """
         if not YAML_AVAILABLE:
             raise NotImplementedError(
                 "YAML support requires PyYAML: pip install pyyaml"
             )
         try:
-            # to_dict should prepare a structure suitable for YAML dumping
+            # If to_dict supports path_type, pass it; otherwise use standard to_dict
+            if "path_type" in self.to_dict.__code__.co_varnames:
+                dict_data = self.to_dict(path_type=path_type)
+            else:
+                dict_data = self.to_dict()
+
             return yaml.dump(
-                self.to_dict(),
+                dict_data,
                 sort_keys=sort_keys,
                 default_flow_style=default_flow_style,
                 allow_unicode=True,
@@ -125,8 +141,19 @@ class Serializable(ABC):
                 f"Failed to deserialize {cls.__name__} from YAML: {e}"
             ) from e
 
-    def to_yaml_file(self, path: Path | str, **yaml_dump_kwargs) -> None:
-        """Serialize to YAML file."""
+    def to_yaml_file(
+        self,
+        path: Path | str,
+        path_type: Literal["absolute", "relative"] = "relative",
+        **yaml_dump_kwargs,
+    ) -> None:
+        """Serialize to YAML file.
+
+        Args:
+            path: File path to write to
+            path_type: How file paths should be formatted ('absolute' or 'relative')
+            **yaml_dump_kwargs: Additional arguments to pass to yaml.dump
+        """
         if not YAML_AVAILABLE:
             raise NotImplementedError(
                 "YAML support requires PyYAML: pip install pyyaml"
@@ -134,7 +161,7 @@ class Serializable(ABC):
         path = Path(path)
         try:
             path.parent.mkdir(parents=True, exist_ok=True)
-            yaml_str = self.to_yaml(**yaml_dump_kwargs)
+            yaml_str = self.to_yaml(path_type=path_type, **yaml_dump_kwargs)
             path.write_text(yaml_str, encoding="utf-8")
         except Exception as e:
             raise RuntimeError(

flock/core/serialization/serialization_utils.py

@@ -1,9 +1,12 @@
 # src/flock/core/serialization/serialization_utils.py
 """Utilities for recursive serialization/deserialization with callable handling."""
 
+import ast
+import builtins
 import importlib
+import sys
 from collections.abc import Mapping, Sequence
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, get_args, get_origin
 
 from pydantic import BaseModel
 
@@ -21,6 +24,98 @@ logger = get_logger("serialization.utils")
 # --- Serialization Helper ---
 
 
+def extract_identifiers_from_type_str(type_str: str) -> set[str]:
+    """Extract all identifiers from a type annotation string using the AST."""
+    tree = ast.parse(type_str, mode="eval")
+    identifiers = set()
+
+    class IdentifierVisitor(ast.NodeVisitor):
+        def visit_Name(self, node):
+            identifiers.add(node.id)
+
+        def visit_Attribute(self, node):
+            # Optionally support dotted names like mymodule.MyModel
+            full_name = []
+            while isinstance(node, ast.Attribute):
+                full_name.append(node.attr)
+                node = node.value
+            if isinstance(node, ast.Name):
+                full_name.append(node.id)
+                identifiers.add(".".join(reversed(full_name)))
+
+    IdentifierVisitor().visit(tree)
+    return identifiers
+
+
+def resolve_name(name: str):
+    """Resolve a name to a Python object from loaded modules."""
+    # Try dotted names first
+    parts = name.split(".")
+    obj = None
+
+    if len(parts) == 1:
+        # Search globals and builtins
+        if parts[0] in globals():
+            return globals()[parts[0]]
+        if parts[0] in builtins.__dict__:
+            return builtins.__dict__[parts[0]]
+    else:
+        try:
+            obj = sys.modules[parts[0]]
+            for part in parts[1:]:
+                obj = getattr(obj, part)
+            return obj
+        except Exception:
+            return None
+
+    # Try all loaded modules' symbols
+    for module in list(sys.modules.values()):
+        if module is None or not hasattr(module, "__dict__"):
+            continue
+        if parts[0] in module.__dict__:
+            return module.__dict__[parts[0]]
+
+    return None
+
+
+def extract_pydantic_models_from_type_string(
+    type_str: str,
+) -> list[type[BaseModel]]:
+    identifiers = extract_identifiers_from_type_str(type_str)
+    models = []
+    for name in identifiers:
+        resolved = resolve_name(name)
+        if (
+            isinstance(resolved, type)
+            and issubclass(resolved, BaseModel)
+            and resolved is not BaseModel
+        ):
+            models.append(resolved)
+    return models
+
+
+def collect_pydantic_models(
+    type_hint, seen: set[type[BaseModel]] | None = None
+) -> set[type[BaseModel]]:
+    if seen is None:
+        seen = set()
+
+    origin = get_origin(type_hint)
+    args = get_args(type_hint)
+
+    # Direct BaseModel
+    if isinstance(type_hint, type) and issubclass(type_hint, BaseModel):
+        seen.add(type_hint)
+        return seen
+
+    # For Unions, Lists, Dicts, Tuples, etc.
+    if origin is not None:
+        for arg in args:
+            collect_pydantic_models(arg, seen)
+
+    return seen
+
+
 def serialize_item(item: Any) -> Any:
     """Recursively prepares an item for serialization (e.g., to dict for YAML/JSON).
     Converts known callables to their path strings using FlockRegistry.

flock/core/util/cli_helper.py

@@ -52,7 +52,7 @@ def init_console(clear_screen: bool = True):
 │ ▒█▀▀▀ █░░ █▀▀█ █▀▀ █░█ │
 │ ▒█▀▀▀ █░░ █░░█ █░░ █▀▄ │
 │ ▒█░░░ ▀▀▀ ▀▀▀▀ ▀▀▀ ▀░▀ │
-╰━━━━━━━━━v{__version__}━━━━━━━━╯
+╰━━━━━━━━v{__version__}━━━━━━━━╯
 🦆     🐤    🐧     🐓
 """,
         justify="center",
@@ -62,7 +62,7 @@ def init_console(clear_screen: bool = True):
         console.clear()
     console.print(banner_text)
     console.print(
-        f"[italic]'Hummingbird'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
+        f"[italic]'Magpie'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
     )