flock-core 0.3.23__py3-none-any.whl → 0.3.30__py3-none-any.whl

flock/core/serialization/serializable.py

@@ -1,12 +1,33 @@
-"""Module for serializable objects in the system."""
-
+# src/flock/core/serialization/serializable.py
 import json
 from abc import ABC, abstractmethod
 from pathlib import Path
 from typing import Any, TypeVar
 
-import cloudpickle
-import msgpack
+# Use yaml if available, otherwise skip yaml methods
+try:
+    import yaml
+
+    YAML_AVAILABLE = True
+except ImportError:
+    YAML_AVAILABLE = False
+
+# Use msgpack if available
+try:
+    import msgpack
+
+    MSGPACK_AVAILABLE = True
+except ImportError:
+    MSGPACK_AVAILABLE = False
+
+# Use cloudpickle
+try:
+    import cloudpickle
+
+    PICKLE_AVAILABLE = True
+except ImportError:
+    PICKLE_AVAILABLE = False
+
 
 T = TypeVar("T", bound="Serializable")
 
@@ -15,79 +36,280 @@ class Serializable(ABC):
     """Base class for all serializable objects in the system.
 
     Provides methods for serializing/deserializing objects to various formats.
+    Subclasses MUST implement to_dict and from_dict.
     """
 
     @abstractmethod
     def to_dict(self) -> dict[str, Any]:
-        """Convert instance to dictionary representation."""
+        """Convert instance to a dictionary representation suitable for serialization.
+        This method should handle converting nested Serializable objects and callables.
+        """
         pass
 
     @classmethod
     @abstractmethod
     def from_dict(cls: type[T], data: dict[str, Any]) -> T:
-        """Create instance from dictionary representation."""
+        """Create instance from a dictionary representation.
+        This method should handle reconstructing nested Serializable objects and callables.
+        """
         pass
 
-    def to_json(self) -> str:
+    # --- JSON Methods ---
+    def to_json(self, indent: int | None = 2) -> str:
         """Serialize to JSON string."""
+        # Import encoder locally to avoid making it a hard dependency if JSON isn't used
+        from .json_encoder import FlockJSONEncoder
+
         try:
-            return json.dumps(self.to_dict())
-        except Exception:
-            raise
+            # Note: to_dict should ideally prepare the structure fully.
+            # FlockJSONEncoder is a fallback for types missed by to_dict.
+            return json.dumps(
+                self.to_dict(), cls=FlockJSONEncoder, indent=indent
+            )
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to serialize {self.__class__.__name__} to JSON: {e}"
+            ) from e
 
     @classmethod
     def from_json(cls: type[T], json_str: str) -> T:
         """Create instance from JSON string."""
         try:
-            return cls.from_dict(json.loads(json_str))
-        except Exception:
+            data = json.loads(json_str)
+            return cls.from_dict(data)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Invalid JSON string: {e}") from e
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to deserialize {cls.__name__} from JSON: {e}"
+            ) from e
+
+    # --- YAML Methods ---
+    def to_yaml(self, sort_keys=False, default_flow_style=False) -> str:
+        """Serialize to YAML string."""
+        if not YAML_AVAILABLE:
+            raise NotImplementedError(
+                "YAML support requires PyYAML: pip install pyyaml"
+            )
+        try:
+            # to_dict should prepare a structure suitable for YAML dumping
+            return yaml.dump(
+                self.to_dict(),
+                sort_keys=sort_keys,
+                default_flow_style=default_flow_style,
+                allow_unicode=True,
+            )
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to serialize {self.__class__.__name__} to YAML: {e}"
+            ) from e
+
+    @classmethod
+    def from_yaml(cls: type[T], yaml_str: str) -> T:
+        """Create instance from YAML string."""
+        if not YAML_AVAILABLE:
+            raise NotImplementedError(
+                "YAML support requires PyYAML: pip install pyyaml"
+            )
+        try:
+            data = yaml.safe_load(yaml_str)
+            if not isinstance(data, dict):
+                raise TypeError(
+                    f"YAML did not yield a dictionary for {cls.__name__}"
+                )
+            return cls.from_dict(data)
+        except yaml.YAMLError as e:
+            raise ValueError(f"Invalid YAML string: {e}") from e
+        except Exception as e:
+            raise RuntimeError(
+                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."""
+        if not YAML_AVAILABLE:
+            raise NotImplementedError(
+                "YAML support requires PyYAML: pip install pyyaml"
+            )
+        path = Path(path)
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            yaml_str = self.to_yaml(**yaml_dump_kwargs)
+            path.write_text(yaml_str, encoding="utf-8")
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to write {self.__class__.__name__} to YAML file {path}: {e}"
+            ) from e
+
+    @classmethod
+    def from_yaml_file(cls: type[T], path: Path | str) -> T:
+        """Create instance from YAML file."""
+        if not YAML_AVAILABLE:
+            raise NotImplementedError(
+                "YAML support requires PyYAML: pip install pyyaml"
+            )
+        path = Path(path)
+        try:
+            yaml_str = path.read_text(encoding="utf-8")
+            return cls.from_yaml(yaml_str)
+        except FileNotFoundError:
             raise
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to read {cls.__name__} from YAML file {path}: {e}"
+            ) from e
 
-    def to_msgpack(self, path: Path | None = None) -> bytes:
+    # --- MsgPack Methods ---
+    def to_msgpack(self) -> bytes:
         """Serialize to msgpack bytes."""
+        if not MSGPACK_AVAILABLE:
+            raise NotImplementedError(
+                "MsgPack support requires msgpack: pip install msgpack"
+            )
         try:
-            msgpack_bytes = msgpack.packb(self.to_dict())
-            if path:
-                path.write_bytes(msgpack_bytes)
-            return msgpack_bytes
-        except Exception:
-            raise
+            # Use default hook for complex types if needed, or rely on to_dict
+            return msgpack.packb(self.to_dict(), use_bin_type=True)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to serialize {self.__class__.__name__} to MsgPack: {e}"
+            ) from e
 
     @classmethod
     def from_msgpack(cls: type[T], msgpack_bytes: bytes) -> T:
         """Create instance from msgpack bytes."""
+        if not MSGPACK_AVAILABLE:
+            raise NotImplementedError(
+                "MsgPack support requires msgpack: pip install msgpack"
+            )
         try:
-            return cls.from_dict(msgpack.unpackb(msgpack_bytes))
-        except Exception:
-            raise
+            # Use object_hook if custom deserialization is needed beyond from_dict
+            data = msgpack.unpackb(msgpack_bytes, raw=False)
+            if not isinstance(data, dict):
+                raise TypeError(
+                    f"MsgPack did not yield a dictionary for {cls.__name__}"
+                )
+            return cls.from_dict(data)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to deserialize {cls.__name__} from MsgPack: {e}"
+            ) from e
+
+    def to_msgpack_file(self, path: Path | str) -> None:
+        """Serialize to msgpack file."""
+        if not MSGPACK_AVAILABLE:
+            raise NotImplementedError(
+                "MsgPack support requires msgpack: pip install msgpack"
+            )
+        path = Path(path)
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            msgpack_bytes = self.to_msgpack()
+            path.write_bytes(msgpack_bytes)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to write {self.__class__.__name__} to MsgPack file {path}: {e}"
+            ) from e
 
     @classmethod
-    def from_msgpack_file(cls: type[T], path: Path) -> T:
+    def from_msgpack_file(cls: type[T], path: Path | str) -> T:
         """Create instance from msgpack file."""
+        if not MSGPACK_AVAILABLE:
+            raise NotImplementedError(
+                "MsgPack support requires msgpack: pip install msgpack"
+            )
+        path = Path(path)
         try:
-            return cls.from_msgpack(path.read_bytes())
-        except Exception:
+            msgpack_bytes = path.read_bytes()
+            return cls.from_msgpack(msgpack_bytes)
+        except FileNotFoundError:
             raise
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to read {cls.__name__} from MsgPack file {path}: {e}"
+            ) from e
 
+    # --- Pickle Methods (Use with caution due to security risks) ---
     def to_pickle(self) -> bytes:
-        """Serialize to pickle bytes."""
+        """Serialize to pickle bytes using cloudpickle."""
+        if not PICKLE_AVAILABLE:
+            raise NotImplementedError(
+                "Pickle support requires cloudpickle: pip install cloudpickle"
+            )
         try:
             return cloudpickle.dumps(self)
-        except Exception:
-            raise
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to serialize {self.__class__.__name__} to Pickle: {e}"
+            ) from e
 
     @classmethod
-    def from_pickle(cls, pickle_bytes: bytes) -> T:
-        """Create instance from pickle bytes."""
+    def from_pickle(cls: type[T], pickle_bytes: bytes) -> T:
+        """Create instance from pickle bytes using cloudpickle."""
+        if not PICKLE_AVAILABLE:
+            raise NotImplementedError(
+                "Pickle support requires cloudpickle: pip install cloudpickle"
+            )
         try:
-            return cloudpickle.loads(pickle_bytes)
-        except Exception:
-            raise
+            instance = cloudpickle.loads(pickle_bytes)
+            if not isinstance(instance, cls):
+                raise TypeError(
+                    f"Deserialized object is not of type {cls.__name__}"
+                )
+            return instance
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to deserialize {cls.__name__} from Pickle: {e}"
+            ) from e
+
+    def to_pickle_file(self, path: Path | str) -> None:
+        """Serialize to pickle file using cloudpickle."""
+        if not PICKLE_AVAILABLE:
+            raise NotImplementedError(
+                "Pickle support requires cloudpickle: pip install cloudpickle"
+            )
+        path = Path(path)
+        try:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            pickle_bytes = self.to_pickle()
+            path.write_bytes(pickle_bytes)
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to write {self.__class__.__name__} to Pickle file {path}: {e}"
+            ) from e
 
     @classmethod
-    def from_pickle_file(cls: type[T], path: Path) -> T:
-        """Create instance from pickle file."""
+    def from_pickle_file(cls: type[T], path: Path | str) -> T:
+        """Create instance from pickle file using cloudpickle."""
+        if not PICKLE_AVAILABLE:
+            raise NotImplementedError(
+                "Pickle support requires cloudpickle: pip install cloudpickle"
+            )
+        path = Path(path)
         try:
-            return cls.from_pickle(path.read_bytes())
-        except Exception:
+            pickle_bytes = path.read_bytes()
+            return cls.from_pickle(pickle_bytes)
+        except FileNotFoundError:
             raise
+        except Exception as e:
+            raise RuntimeError(
+                f"Failed to read {cls.__name__} from Pickle file {path}: {e}"
+            ) from e
+
+    # _filter_none_values remains unchanged
+    @staticmethod
+    def _filter_none_values(data: Any) -> Any:
+        """Filter out None values from dictionaries and lists recursively."""
+        if isinstance(data, dict):
+            return {
+                k: Serializable._filter_none_values(v)
+                for k, v in data.items()
+                if v is not None
+            }
+        elif isinstance(data, list):
+            # Filter None from list items AND recursively filter within items
+            return [
+                Serializable._filter_none_values(item)
+                for item in data
+                if item is not None
+            ]
+        return data

flock/core/serialization/serialization_utils.py

@@ -0,0 +1,184 @@
+# src/flock/core/serialization/serialization_utils.py
+"""Utilities for recursive serialization/deserialization with callable handling."""
+
+import importlib
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from pydantic import BaseModel
+
+# Import the registry
+# from .callable_registry import CallableRegistry # Old way
+from flock.core.flock_registry import (
+    COMPONENT_BASE_TYPES,
+    get_registry,  # New way
+)
+from flock.core.logging.logging import get_logger
+
+logger = get_logger("serialization.utils")
+FlockRegistry = get_registry()  # Get singleton instance
+
+# --- Serialization Helper ---
+
+
+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.
+    Converts Pydantic models using model_dump.
+    """
+    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 path_str:
+            return {"__callable_ref__": path_str}
+        else:
+            logger.warning(
+                f"Could not get path string for callable {item}, storing as string."
+            )
+            return str(item)
+    elif isinstance(item, Mapping):
+        return {key: serialize_item(value) for key, value in item.items()}
+    elif isinstance(item, Sequence) and not isinstance(item, str):
+        return [serialize_item(sub_item) for sub_item in item]
+    elif isinstance(
+        item, type
+    ):  # Handle type objects themselves (e.g. if stored directly)
+        type_name = FlockRegistry.get_component_type_name(
+            item
+        )  # Check components first
+        if type_name:
+            return {"__component_ref__": type_name}
+        type_name = FlockRegistry._get_path_string(
+            item
+        )  # 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."
+        )
+        return str(item)
+    else:
+        # Return basic types as is
+        return item
+
+
+# --- Deserialization Helper ---
+
+
+def deserialize_item(item: Any) -> Any:
+    """Recursively processes a deserialized item (e.g., from YAML/JSON dict).
+    Converts reference dicts back to actual callables or types using FlockRegistry.
+    Handles nested lists and dicts.
+    """
+    if isinstance(item, Mapping):
+        if "__callable_ref__" in item and len(item) == 1:
+            path_str = item["__callable_ref__"]
+            try:
+                return FlockRegistry.get_callable(path_str)
+            except KeyError:
+                logger.error(
+                    f"Callable reference '{path_str}' not found during deserialization."
+                )
+                return None
+        elif "__component_ref__" in item and len(item) == 1:
+            type_name = item["__component_ref__"]
+            try:
+                return FlockRegistry.get_component(type_name)
+            except KeyError:
+                logger.error(
+                    f"Component reference '{type_name}' not found during deserialization."
+                )
+                return None
+        elif "__type_ref__" in item and len(item) == 1:
+            type_name = item["__type_ref__"]
+            try:
+                # For general types, use get_type or fallback to dynamic import like get_callable
+                # Using get_type for now, assuming it needs registration
+                return FlockRegistry.get_type(type_name)
+            except KeyError:
+                # Attempt dynamic import as fallback if get_type fails (similar to get_callable)
+                try:
+                    if "." not in type_name:  # Builtins?
+                        mod = importlib.import_module("builtins")
+                    else:
+                        module_name, class_name = type_name.rsplit(".", 1)
+                        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
+                        return type_obj
+                    else:
+                        raise TypeError()
+                except Exception:
+                    logger.error(
+                        f"Type reference '{type_name}' not found in registry or via dynamic import."
+                    )
+                    return None
+
+        else:
+            # Recursively deserialize dictionary values
+            return {key: deserialize_item(value) for key, value in item.items()}
+    elif isinstance(item, Sequence) and not isinstance(item, str):
+        return [deserialize_item(sub_item) for sub_item in item]
+    else:
+        # Return basic types as is
+        return item
+
+
+# --- Component Deserialization Helper ---
+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.
+    """
+    if data is None:
+        return None
+    if not isinstance(data, dict):
+        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
+    if not type_name:
+        logger.error(f"Component data missing 'type' field: {data}")
+        return None
+
+    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
+        ):
+            raise TypeError(
+                f"Deserialized class {type_name} is not a subclass of {expected_base_type.__name__}"
+            )
+
+        # Recursively deserialize the data *before* passing to Pydantic constructor
+        # This handles nested callables/types within the component's config/data
+        deserialized_data_for_init = {}
+        for k, v in data.items():
+            # Don't pass the 'type' field itself to the constructor if it matches class name
+            if k == "type" and v == ComponentClass.__name__:
+                continue
+            deserialized_data_for_init[k] = deserialize_item(v)
+
+        # Use Pydantic constructor directly. Assumes keys match field names.
+        # from_dict could be added to components for more complex logic if needed.
+        return ComponentClass(**deserialized_data_for_init)
+
+    except (KeyError, TypeError, Exception) as e:
+        logger.error(
+            f"Failed to deserialize component of type '{type_name}': {e}",
+            exc_info=True,
+        )
+        return None

flock/workflow/activities.py

@@ -8,9 +8,9 @@ from temporalio import activity
 from flock.core.context.context import FlockContext
 from flock.core.context.context_vars import FLOCK_CURRENT_AGENT, FLOCK_MODEL
 from flock.core.flock_agent import FlockAgent
+from flock.core.flock_registry import get_registry
 from flock.core.flock_router import HandOffRequest
 from flock.core.logging.logging import get_logger
-from flock.core.registry.agent_registry import Registry
 from flock.core.util.input_resolver import resolve_inputs
 
 logger = get_logger("activities")
@@ -26,7 +26,7 @@ async def run_agent(context: FlockContext) -> dict:
     """
     # Start a top-level span for the entire run_agent activity.
     with tracer.start_as_current_span("run_agent") as span:
-        registry = Registry()
+        registry = get_registry()
         previous_agent_name = ""
         if isinstance(context, dict):
             context = FlockContext.from_dict(context)

{flock_core-0.3.23.dist-info → flock_core-0.3.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.3.23
+Version: 0.3.30
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -12,10 +12,11 @@ Requires-Dist: azure-search-documents>=11.5.2
 Requires-Dist: chromadb>=0.6.3
 Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: devtools>=0.12.2
-Requires-Dist: dspy==2.5.42
+Requires-Dist: dspy==2.6.16
 Requires-Dist: duckduckgo-search>=7.3.2
 Requires-Dist: fastapi>=0.115.8
 Requires-Dist: httpx>=0.28.1
+Requires-Dist: litellm==1.63.7
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: matplotlib>=3.10.0
 Requires-Dist: msgpack>=1.1.0
@@ -33,6 +34,8 @@ Requires-Dist: pydantic>=2.10.5
 Requires-Dist: python-box>=7.3.2
 Requires-Dist: python-decouple>=3.8
 Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: python-fasthtml>=0.12.6
+Requires-Dist: pyyaml>=6.0
 Requires-Dist: questionary>=2.1.0
 Requires-Dist: rich>=13.9.4
 Requires-Dist: sentence-transformers>=3.4.1
@@ -59,7 +62,7 @@ Description-Content-Type: text/markdown
 
 ## Overview
 
-Flock is a framework for orchestrating LLM-powered agents. It leverages a **declarative approach** where you simply specify what each agent needs as input and what it produces as output—without having to write lengthy, brittle prompts. Under the hood, Flock transforms these declarations into robust workflows, using cutting-edge components such as Temporal and DSPy to handle fault tolerance, state management, and error recovery.
+Flock is a framework for orchestrating LLM-powered agents. It leverages a **declarative approach** where you simply specify what each agent needs as input and what it produces as output, without having to write lengthy, brittle prompts. Under the hood, Flock transforms these declarations into robust workflows, using cutting-edge components such as Temporal and DSPy to handle fault tolerance, state management, and error recovery.
 
 
 

{flock_core-0.3.23.dist-info → flock_core-0.3.30.dist-info}/RECORD

@@ -9,14 +9,22 @@ flock/cli/load_flock.py,sha256=3JdECvt5X7uyOG2vZS3-Zk5C5SI_84_QZjcsB3oJmfA,932
 flock/cli/load_release_notes.py,sha256=qFcgUrMddAE_TP6x1P-6ZywTUjTknfhTDW5LTxtg1yk,599
 flock/cli/settings.py,sha256=Z_TXBzCYlCmSaKrJ_CQCdYy-Cj29gpI4kbC_2KzoKqg,27025
 flock/cli/assets/release_notes.md,sha256=bqnk50jxM3w5uY44Dc7MkdT8XmRREFxrVBAG9XCOSSU,4896
-flock/core/__init__.py,sha256=mPlvKc0SxC2qCvSlgYeP_7EyV8ptmdn24NO8mlQoCSo,559
-flock/core/flock.py,sha256=IURlcuNvdsnqKkvgXtX4v_pGWQ8Lfb60X--MT0zvxHo,19881
-flock/core/flock_agent.py,sha256=F1wl54ivLQijSHlv_Q_znw_ElzdDlqpi-KugVUyHTRE,12238
-flock/core/flock_api.py,sha256=2rHnmEdtT5KPZYwGesRT7LqwbrgKClODHT-O56u7pcQ,7140
+flock/core/__init__.py,sha256=6NmSXsdQOoOPWjWqdF8BYiUveb54CjH8Ta0WAjNM0Ps,574
+flock/core/flock.py,sha256=O2ro_CZMKi_8ssY7BYpT6wSENcvcimO9mqwIxqENMpg,22202
+flock/core/flock_agent.py,sha256=jkDwB7yVGYyLfg-WuwvR2X4XblXOs5DrB2dB30xBL7Q,24754
 flock/core/flock_evaluator.py,sha256=dOXZeDOGZcAmJ9ahqq_2bdGUU1VOXY4skmwTVpAjiVw,1685
 flock/core/flock_factory.py,sha256=MGTkJCP1WGpV614f87r1vwe0tqAvBCoH9PlqtqDyJDk,2828
 flock/core/flock_module.py,sha256=96aFVYAgwpKN53xGbivQDUpikOYGFCxK5mqhclOcxY0,3003
+flock/core/flock_registry.py,sha256=cqW74n6RebrQ7uqqLb6DxBNxebqJsu4WyMtL1BcS5oI,22551
 flock/core/flock_router.py,sha256=A5GaxcGvtiFlRLHBTW7okh5RDm3BdKam2uXvRHRaj7k,2187
+flock/core/api/__init__.py,sha256=OKlhzDWZJfA6ddBwxQUmATY0TSzESsH032u00iVGvdA,228
+flock/core/api/endpoints.py,sha256=m-QAyizCHGh3sd5IXaDEhquSxNgTZLpUVTXLdVjiDVw,9086
+flock/core/api/main.py,sha256=-MJClTcmkyUnaP9fmVu2CcHagFy_9lKk6CAbF05kraY,8928
+flock/core/api/models.py,sha256=mMPCMCD52Txc56_yscwZQG0RRPCJTnIrVKQ8WbI7gts,1111
+flock/core/api/run_store.py,sha256=kmrb0bq2Et5JiSxFWskAAf5a4jTeEFVZShTDlX5jfAk,2773
+flock/core/api/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+flock/core/api/ui/routes.py,sha256=nS-wWO94mshE5ozWfOQZ-HOvtes_1qxDVcqpMZtU5JQ,8885
+flock/core/api/ui/utils.py,sha256=V7PqYHNK519hFJ8jvvwf7bGpbBXCRz_HQG3BDCCqlNA,4802
 flock/core/context/context.py,sha256=8bjRLZ74oacRNBaHmDNXdQKfB-95poF7Pp03n2k0zcQ,6437
 flock/core/context/context_manager.py,sha256=FANSWa6DEhdhtZ7t_9Gza0v80UdpoDOhHbfVOccmjkA,1181
 flock/core/context/context_vars.py,sha256=zYTMi9b6mNSSEHowEQUOTpEDurmAjaUcyBCgfKY6-cU,300
@@ -24,7 +32,7 @@ flock/core/execution/local_executor.py,sha256=rnIQvaJOs6zZORUcR3vvyS6LPREDJTjayg
 flock/core/execution/temporal_executor.py,sha256=OF_uXgQsoUGp6U1ZkcuaidAEKyH7XDtbfrtdF10XQ_4,1675
 flock/core/interpreter/python_interpreter.py,sha256=RaUMZuufsKBNQ4FAeSaOgUuxzs8VYu5TgUUs-xwaxxM,26376
 flock/core/logging/__init__.py,sha256=Q8hp9-1ilPIUIV0jLgJ3_cP7COrea32cVwL7dicPnlM,82
-flock/core/logging/logging.py,sha256=uWtUZnQI_sdtzLfXo61JPENSNNwplvEuGMPIhsYd-gQ,12448
+flock/core/logging/logging.py,sha256=-ViLNLTm5wqbvVsc6xYekOsAY38ZCIn6j1wciC7lgeM,15417
 flock/core/logging/telemetry.py,sha256=3E9Tyj6AUR6A5RlIufcdCdWm5BAA7tbOsCa7lHoUQaU,5404
 flock/core/logging/trace_and_logged.py,sha256=5vNrK1kxuPMoPJ0-QjQg-EDJL1oiEzvU6UNi6X8FiMs,2117
 flock/core/logging/formatters/enum_builder.py,sha256=LgEYXUv84wK5vwHflZ5h8HBGgvLH3sByvUQe8tZiyY0,981
@@ -35,13 +43,14 @@ flock/core/logging/span_middleware/baggage_span_processor.py,sha256=gJfRl8FeB6jd
 flock/core/logging/telemetry_exporter/base_exporter.py,sha256=rQJJzS6q9n2aojoSqwCnl7ZtHrh5LZZ-gkxUuI5WfrQ,1124
 flock/core/logging/telemetry_exporter/file_exporter.py,sha256=nKAjJSZtA7FqHSTuTiFtYYepaxOq7l1rDvs8U8rSBlA,3023
 flock/core/logging/telemetry_exporter/sqlite_exporter.py,sha256=CDsiMb9QcqeXelZ6ZqPSS56ovMPGqOu6whzBZRK__Vg,3498
-flock/core/mixin/dspy_integration.py,sha256=P5G4Y04nl5hFwFbJXCkQ-0TMR1L4skLL2IM_FlUjH_c,8364
+flock/core/mixin/dspy_integration.py,sha256=Os2jZ505t_7Mg5jllUc06uDpCNTnhGBeCbUW-yAHfXc,17366
 flock/core/mixin/prompt_parser.py,sha256=eOqI-FK3y17gVqpc_y5GF-WmK1Jv8mFlkZxTcgweoxI,5121
-flock/core/registry/agent_registry.py,sha256=TUClh9e3eA6YzZC1CMTlsTPvQeqb9jYHewi-zPpcWM8,4987
-flock/core/serialization/__init__.py,sha256=j0uw1g-7SOEhD5Ozgc8WpbZNpDWRmu58UOGg4_QTu8U,320
+flock/core/serialization/__init__.py,sha256=CML7fPgG6p4c0CDBlJ_uwV1aZZhJKK9uy3IoIHfO87w,431
+flock/core/serialization/callable_registry.py,sha256=sUZECTZWsM3fJ8FDRQ-FgLNW9hF26nY17AD6fJKADMc,1419
 flock/core/serialization/json_encoder.py,sha256=gAKj2zU_8wQiNvdkby2hksSA4fbPNwTjup_yz1Le1Vw,1229
 flock/core/serialization/secure_serializer.py,sha256=n5-zRvvXddgJv1FFHsaQ2wuYdL3WUSGPvG_LGaffEJo,6144
-flock/core/serialization/serializable.py,sha256=SymJ0YrjBx48mOBItYSqoRpKuzIc4vKWRS6ScTzre7s,2573
+flock/core/serialization/serializable.py,sha256=ymuJmm8teLbyUFMakkD7W3a_N8H4igZ1ITQnOqoLt0o,11270
+flock/core/serialization/serialization_utils.py,sha256=UgMYYccwgfGxyMJ7qYaQ9-RWWjiE9p9qMehoY_X1zi0,7146
 flock/core/tools/azure_tools.py,sha256=9Bi6IrB5pzBTBhBSxpCVMgx8HBud8nl4gDp8aN0NT6c,17031
 flock/core/tools/basic_tools.py,sha256=hEG14jNZ2itVvubCHTfsWkuJK6yuNwBtuFj2Js0VHZs,9043
 flock/core/tools/llm_tools.py,sha256=Bdt4Dpur5dGpxd2KFEQyxjfZazvW1HCDKY6ydMj6UgQ,21811
@@ -410,12 +419,12 @@ flock/themes/zenburned.toml,sha256=UEmquBbcAO3Zj652XKUwCsNoC2iQSlIh-q5c6DH-7Kc,1
 flock/themes/zenwritten-dark.toml,sha256=To5l6520_3UqAGiEumpzGWsHhXxqu9ThrMildXKgIO0,1669
 flock/themes/zenwritten-light.toml,sha256=G1iEheCPfBNsMTGaVpEVpDzYBHA_T-MV27rolUYolmE,1666
 flock/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-flock/workflow/activities.py,sha256=yah-lHjMW6_Ww1gt7hMXBis1cJRlcbHx0uLsMB9oNZ0,9066
+flock/workflow/activities.py,sha256=eVZDnxGJl_quNO-UTV3YgvTV8LrRaHN3QDAA1ANKzac,9065
 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.3.23.dist-info/METADATA,sha256=qwn0OaG4E4j-5vjAPcqSv6jqpxtL8e5NcuhyHgKHkCY,20649
-flock_core-0.3.23.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.3.23.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.3.23.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.3.23.dist-info/RECORD,,
+flock_core-0.3.30.dist-info/METADATA,sha256=tEQMna6bPKeaSix98h5NnqVnb8vN8IQLtiKE3DP_F2U,20745
+flock_core-0.3.30.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.3.30.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.3.30.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.3.30.dist-info/RECORD,,