flock-core 0.4.0b20__py3-none-any.whl → 0.4.0b22__py3-none-any.whl

flock/core/flock.py

@@ -350,13 +350,9 @@ 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()
@@ -388,20 +384,15 @@ 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:
@@ -409,17 +400,13 @@ 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/logging/logging.py

@@ -144,9 +144,7 @@ def custom_format(record):
     level_name = record["level"].name
     category = record["extra"].get("category", "unknown")
     trace_id = record["extra"].get("trace_id", "no-trace")
-    color_tag = color_for_category(
-        category
-    )  # Get the color tag name (e.g., "yellow")
+    color_tag = color_for_category(category)  # Get the color tag name (e.g., "yellow")
 
     message = record["message"]
     message = message.replace("{", "{{").replace("}", "}}")
@@ -155,8 +153,7 @@ def custom_format(record):
     if len(message) > MAX_LENGTH:
         truncated_chars = len(message) - MAX_LENGTH
         message = (
-            message[:MAX_LENGTH]
-            + f"<yellow>...+({truncated_chars} chars)</yellow>"
+            message[:MAX_LENGTH] + f"<yellow>...+({truncated_chars} chars)</yellow>"
         )
 
     # Determine if category needs bolding (can refine this logic)
@@ -164,13 +161,9 @@ def custom_format(record):
 
     # Apply tags sequentially
     category_styled = f"[{category}]"  # Start with the plain category name
-    category_styled = (
-        f"<{color_tag}>{category_styled}</{color_tag}>"  # Wrap with color
-    )
+    category_styled = f"<{color_tag}>{category_styled}</{color_tag}>"  # Wrap with color
     if needs_bold:
-        category_styled = (
-            f"<bold>{category_styled}</bold>"  # Wrap with bold if needed
-        )
+        category_styled = f"<bold>{category_styled}</bold>"  # Wrap with bold if needed
 
     # Final format string using sequential tags for category
     return (
@@ -311,8 +304,7 @@ class FlockLogger:
         if len(message) > max_length:
             truncated_chars = len(message) - max_length
             return (
-                message[:max_length]
-                + f"...<yellow>+({truncated_chars} chars)</yellow>"
+                message[:max_length] + f"...<yellow>+({truncated_chars} chars)</yellow>"
             )
         return message
 
@@ -454,10 +446,7 @@ def get_module_loggers() -> list[FlockLogger]:
 def truncate_for_logging(obj, max_item_length=100, max_items=10):
     """Truncate large data structures for logging purposes."""
     if isinstance(obj, str) and len(obj) > max_item_length:
-        return (
-            obj[:max_item_length]
-            + f"... ({len(obj) - max_item_length} more chars)"
-        )
+        return obj[:max_item_length] + f"... ({len(obj) - max_item_length} more chars)"
     elif isinstance(obj, dict):
         if len(obj) > max_items:
             return {

flock/core/mixin/dspy_integration.py

@@ -93,26 +93,20 @@ def _resolve_type_string(type_str: str) -> type:
     if generic_match:
         base_name = generic_match.group(1).strip()
         args_str = generic_match.group(2).strip()
-        logger.debug(
-            f"Detected generic pattern: Base='{base_name}', Args='{args_str}'"
-        )
+        logger.debug(f"Detected generic pattern: Base='{base_name}', Args='{args_str}'")
 
         try:
             # Get the base generic type (e.g., list, dict, Optional) from registry/builtins
             BaseType = FlockRegistry.get_type(
                 base_name
             )  # Expects List, Dict etc. to be registered
-            logger.debug(
-                f"Resolved base generic type '{base_name}' to: {BaseType}"
-            )
+            logger.debug(f"Resolved base generic type '{base_name}' to: {BaseType}")
 
             # Special handling for Literal
             if BaseType is typing.Literal:
                 # Split literal values, remove quotes, strip whitespace
                 literal_args_raw = split_top_level(args_str)
-                literal_args = tuple(
-                    s.strip().strip("'\"") for s in literal_args_raw
-                )
+                literal_args = tuple(s.strip().strip("'\"") for s in literal_args_raw)
                 logger.debug(
                     f"Parsing Literal arguments: {literal_args_raw} -> {literal_args}"
                 )
@@ -127,9 +121,7 @@ def _resolve_type_string(type_str: str) -> type:
             if not arg_strs:
                 raise ValueError("Generic type has no arguments.")
 
-            resolved_arg_types = tuple(
-                _resolve_type_string(arg) for arg in arg_strs
-            )
+            resolved_arg_types = tuple(_resolve_type_string(arg) for arg in arg_strs)
             logger.debug(f"Resolved generic arguments: {resolved_arg_types}")
 
             # Construct the generic type hint
@@ -137,9 +129,7 @@ def _resolve_type_string(type_str: str) -> type:
                 if len(resolved_arg_types) != 1:
                     raise ValueError("Optional requires exactly one argument.")
                 resolved_type = typing.Union[resolved_arg_types[0], type(None)]  # type: ignore
-                logger.debug(
-                    f"Constructed Optional type as Union: {resolved_type}"
-                )
+                logger.debug(f"Constructed Optional type as Union: {resolved_type}")
                 return resolved_type
             elif BaseType is typing.Union:
                 if not resolved_arg_types:
@@ -151,9 +141,7 @@ def _resolve_type_string(type_str: str) -> type:
                 BaseType, "__getitem__"
             ):  # Check if subscriptable (like list, dict, List, Dict)
                 resolved_type = BaseType[resolved_arg_types]  # type: ignore
-                logger.debug(
-                    f"Constructed subscripted generic type: {resolved_type}"
-                )
+                logger.debug(f"Constructed subscripted generic type: {resolved_type}")
                 return resolved_type
             else:
                 # Base type found but cannot be subscripted
@@ -244,15 +232,11 @@ class DSPyIntegrationMixin:
                     )
 
                     FieldClass = (
-                        dspy.InputField
-                        if field_kind == "input"
-                        else dspy.OutputField
+                        dspy.InputField if field_kind == "input" else dspy.OutputField
                     )
                     # DSPy Fields use 'desc' for description
                     class_dict[name] = (
-                        FieldClass(desc=desc)
-                        if desc is not None
-                        else FieldClass()
+                        FieldClass(desc=desc) if desc is not None else FieldClass()
                     )
 
         try:
@@ -263,15 +247,11 @@ class DSPyIntegrationMixin:
                 f"Error processing fields for DSPy signature '{agent_name}': {e}",
                 exc_info=True,
             )
-            raise ValueError(
-                f"Could not process fields for signature: {e}"
-            ) from e
+            raise ValueError(f"Could not process fields for signature: {e}") from e
 
         # Create and return the dynamic class
         try:
-            DynamicSignature = type(
-                "dspy_" + agent_name, (base_class,), class_dict
-            )
+            DynamicSignature = type("dspy_" + agent_name, (base_class,), class_dict)
             logger.info(
                 f"Successfully created DSPy Signature: {DynamicSignature.__name__} "
                 f"with fields: {DynamicSignature.__annotations__}"
@@ -344,9 +324,7 @@ class DSPyIntegrationMixin:
         try:
             import dspy
         except ImportError:
-            logger.error(
-                "DSPy library is not installed. Cannot select DSPy task."
-            )
+            logger.error("DSPy library is not installed. Cannot select DSPy task.")
             raise ImportError("DSPy is required for this functionality.")
 
         processed_tools = []
@@ -365,9 +343,7 @@ class DSPyIntegrationMixin:
 
         # Determine type if not overridden
         if not selected_type:
-            selected_type = (
-                "ReAct" if processed_tools else "Predict"
-            )  # Default logic
+            selected_type = "ReAct" if processed_tools else "Predict"  # Default logic
 
         logger.debug(
             f"Selecting DSPy program type: {selected_type} (Tools provided: {bool(processed_tools)})"
@@ -390,9 +366,7 @@ class DSPyIntegrationMixin:
                 )
                 dspy_program = dspy.Predict(signature)
 
-            logger.info(
-                f"Instantiated DSPy program: {type(dspy_program).__name__}"
-            )
+            logger.info(f"Instantiated DSPy program: {type(dspy_program).__name__}")
             return dspy_program
         except Exception as e:
             logger.error(
@@ -416,9 +390,7 @@ class DSPyIntegrationMixin:
                 output_dict = dict(result.items())
             elif hasattr(result, "__dict__"):  # Fallback for other object types
                 output_dict = {
-                    k: v
-                    for k, v in result.__dict__.items()
-                    if not k.startswith("_")
+                    k: v for k, v in result.__dict__.items() if not k.startswith("_")
                 }
             else:
                 # If it's already a dict (less common for DSPy results directly)
@@ -436,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

@@ -57,9 +57,7 @@ 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:
@@ -68,9 +66,7 @@ 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)
@@ -87,9 +83,7 @@ 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
 
 
@@ -199,9 +193,7 @@ def serialize_item(item: Any) -> Any:
         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
+        path_str = FlockRegistry.get_callable_path_string(item)  # Use registry helper
         if path_str:
             return {"__callable_ref__": path_str}
         else:
@@ -226,9 +218,7 @@ 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)
     else:
         # Return basic types as is
@@ -283,9 +273,7 @@ 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()
@@ -306,9 +294,7 @@ 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.
     """
@@ -320,14 +306,10 @@ def deserialize_component(
     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
@@ -335,9 +317,7 @@ def deserialize_component(
     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/cli_helper.py

@@ -64,14 +64,14 @@ def init_console(clear_screen: bool = True, show_banner: bool = True):
     if show_banner:
         console.print(banner_text)
     console.print(
-        f"[italic]'Magpie'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
+        "[italic]'Magpie'[/] milestone - [bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n"
     )
 
 
 def display_banner_no_version():
     """Display the Flock banner."""
     banner_text = Text(
-        f"""
+        """
 🦆    🐓     🐤     🐧
 ╭━━━━━━━━━━━━━━━━━━━━━━━━╮
 │ ▒█▀▀▀ █░░ █▀▀█ █▀▀ █░█ │
@@ -84,4 +84,4 @@ def display_banner_no_version():
         style="bold orange3",
     )
     console.print(banner_text)
-    console.print(f"[bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n")
+    console.print("[bold]white duck GmbH[/] - [cyan]https://whiteduck.de[/]\n")

flock/core/util/hydrator.py

@@ -21,9 +21,7 @@ logger = get_logger("hydrator")
 T = TypeVar("T", bound=BaseModel)
 
 
-def flockclass(
-    model: str = "openai/gpt-4o", agent_description: str | None = None
-):
+def flockclass(model: str = "openai/gpt-4o", agent_description: str | None = None):
     """Decorator to add a .hydrate() method to a Pydantic class.
     Leverages a dynamic Flock agent to fill missing (None) fields.
 
@@ -90,9 +88,7 @@ def flockclass(
                 return self  # Return early if agent run failed
 
             # Update object fields with results
-            _update_fields_with_results(
-                self, result, missing_fields, class_name
-            )
+            _update_fields_with_results(self, result, missing_fields, class_name)
 
             return self
 
@@ -109,9 +105,7 @@ def flockclass(
                     import concurrent.futures
 
                     with concurrent.futures.ThreadPoolExecutor() as executor:
-                        future = executor.submit(
-                            asyncio.run, hydrate_async(self)
-                        )
+                        future = executor.submit(asyncio.run, hydrate_async(self))
                         return future.result()
                 else:
                     # There's a loop but it's not running
@@ -124,9 +118,7 @@ def flockclass(
         # Attach the methods to the class
         setattr(cls, "hydrate_async", hydrate_async)
         setattr(cls, "hydrate", hydrate)
-        setattr(
-            cls, "hydrate_sync", hydrate
-        )  # Alias for backward compatibility
+        setattr(cls, "hydrate_sync", hydrate)  # Alias for backward compatibility
 
         logger.debug(f"Attached hydrate methods to class {cls.__name__}")
         return cls
@@ -141,14 +133,10 @@ def _get_model_fields(
     try:
         if hasattr(obj, "model_fields"):  # Pydantic v2
             all_fields = obj.model_fields
-            type_hints = {
-                name: field.annotation for name, field in all_fields.items()
-            }
+            type_hints = {name: field.annotation for name, field in all_fields.items()}
         else:  # Pydantic v1 fallback
             type_hints = get_type_hints(obj.__class__)
-            all_fields = getattr(
-                obj, "__fields__", {name: None for name in type_hints}
-            )
+            all_fields = getattr(obj, "__fields__", {name: None for name in type_hints})
         return all_fields, type_hints
     except Exception as e:
         logger.error(
@@ -268,9 +256,7 @@ async def _run_hydration_agent(
             else {"context_info": {"object_type": class_name}}
         )
 
-        logger.info(
-            f"Running hydration agent '{agent_name}' for {class_name}..."
-        )
+        logger.info(f"Running hydration agent '{agent_name}' for {class_name}...")
 
         # Run agent
         result = await temp_flock.run_async(
@@ -278,9 +264,7 @@ async def _run_hydration_agent(
             input=agent_input_data,
             box_result=False,
         )
-        logger.info(
-            f"Hydration agent returned for {class_name}: {list(result.keys())}"
-        )
+        logger.info(f"Hydration agent returned for {class_name}: {list(result.keys())}")
 
         return result
 

flock/evaluators/declarative/declarative_evaluator.py

@@ -35,9 +35,7 @@ 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(
@@ -91,14 +89,10 @@ class DeclarativeEvaluator(
 
         # --- 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)
@@ -150,7 +144,7 @@ class DeclarativeEvaluator(
                 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:

{flock_core-0.4.0b20.dist-info → flock_core-0.4.0b22.dist-info}/METADATA

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

{flock_core-0.4.0b20.dist-info → flock_core-0.4.0b22.dist-info}/RECORD

@@ -19,7 +19,7 @@ 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=K7EsY7K8avH57mJ3I_y0Ehlk0G8bYt4ZpBFYPtjgZ4o,25420
+flock/core/flock.py,sha256=RcDUc__ukjUy9aSA_n0t8SxXCex4BV_nagTcg22peJ0,25116
 flock/core/flock_agent.py,sha256=ZmkiHd2oLao_263b7nmf26TQfyevX9_HNlhHPIkd3UM,33497
 flock/core/flock_evaluator.py,sha256=dOXZeDOGZcAmJ9ahqq_2bdGUU1VOXY4skmwTVpAjiVw,1685
 flock/core/flock_factory.py,sha256=vLkCASLh7Vrb5NFjb4ZQT5xN3zsUDud51hAQxb82oTk,2993
@@ -45,7 +45,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=-Mzft9GOahe0cOQtNbdlh0yLH-00ZAl713xHugtRFeQ,15527
+flock/core/logging/logging.py,sha256=JcgABQ8QJU1hhzhfF93eqnE0jhyXGZ2oObZst68sKR8,15409
 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
@@ -56,7 +56,7 @@ 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=MplWCkJZymtmf1646yUYlpBxaz39SOenW7EQ1SpSQnE,17681
+flock/core/mixin/dspy_integration.py,sha256=JlGtakuy_lXXEEXBycd7ygmdUBKS-4qPWNqx3Wqfy78,17187
 flock/core/mixin/prompt_parser.py,sha256=eOqI-FK3y17gVqpc_y5GF-WmK1Jv8mFlkZxTcgweoxI,5121
 flock/core/serialization/__init__.py,sha256=CML7fPgG6p4c0CDBlJ_uwV1aZZhJKK9uy3IoIHfO87w,431
 flock/core/serialization/callable_registry.py,sha256=sUZECTZWsM3fJ8FDRQ-FgLNW9hF26nY17AD6fJKADMc,1419
@@ -64,19 +64,19 @@ flock/core/serialization/flock_serializer.py,sha256=TEePKaJqU-_XWHTMWyMHloDNwmkK
 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=qlv8TsTqRuklXiNuCMrvro5VKz764xC2i3FlgLJSkdk,12129
-flock/core/serialization/serialization_utils.py,sha256=n5q6P18dEK1JHejgFhAv-87mODjKuz36GYV1n6p-VO4,12924
+flock/core/serialization/serialization_utils.py,sha256=63CV41Jba29EEqS85h_6ADgbeYvVmfILmbXv742LiXQ,12702
 flock/core/tools/azure_tools.py,sha256=hwLnI2gsEq6QzUoWj5eCGDKTdXY1XUf6K-H5Uwva2MY,17093
 flock/core/tools/basic_tools.py,sha256=Ye7nlI4RRkqWRy8nH9CKuItBmh_ZXxUpouGnCOfx0s0,9050
 flock/core/tools/llm_tools.py,sha256=Bdt4Dpur5dGpxd2KFEQyxjfZazvW1HCDKY6ydMj6UgQ,21811
 flock/core/tools/markdown_tools.py,sha256=W6fGM48yGHbifVlaOk1jOtVcybfRbRmf20VbDOZv8S4,6031
 flock/core/tools/zendesk_tools.py,sha256=deZAyUi9j-_yZaTayLQVJaFXIqIct-P6C8IGN5UU_tM,3528
 flock/core/tools/dev_tools/github.py,sha256=a2OTPXS7kWOVA4zrZHynQDcsmEi4Pac5MfSjQOLePzA,5308
-flock/core/util/cli_helper.py,sha256=nbA3n7zpVopV7bDf_aB3HHRYXmIBSwT1yqpjiVl4r9g,49848
+flock/core/util/cli_helper.py,sha256=EnK4X-FgaO71JsSXLdy0R-cxE3UctlFZtzldursw-Bw,49845
 flock/core/util/file_path_utils.py,sha256=Odf7uU32C-x1KNighbNERSiMtkzW4h8laABIoFK7A5M,6246
-flock/core/util/hydrator.py,sha256=z0kvqr4j3piExOb_T5EgATuNm77ZlqIKvLpt4PJusO8,10949
+flock/core/util/hydrator.py,sha256=QJvCA8F4nkSP5akp3yg0cT6oaajOr1n7sldW5dCs6Lo,10733
 flock/core/util/input_resolver.py,sha256=g9vDPdY4OH-G7qjas5ksGEHueokHGFPMoLOvC-ngeLo,5984
 flock/core/util/loader.py,sha256=j3q2qem5bFMP2SmMuYjb-ISxsNGNZd1baQmpvAnRUUk,2244
-flock/evaluators/declarative/declarative_evaluator.py,sha256=Pi1GsQUGL8eJrl6GFWYpu7O9kXI11xIskdBVg08n8mo,6055
+flock/evaluators/declarative/declarative_evaluator.py,sha256=6FCUPf0ArckwYzNXcYAd4NcR0254e24jJadSxbStMx0,5987
 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
@@ -441,8 +441,8 @@ flock/workflow/activities.py,sha256=eVZDnxGJl_quNO-UTV3YgvTV8LrRaHN3QDAA1ANKzac,
 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.0b20.dist-info/METADATA,sha256=gHmRUklybXUkMM1Z_XDaMxCcgVzOpSeS9ksy1MUZfIw,12970
-flock_core-0.4.0b20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.4.0b20.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.4.0b20.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.4.0b20.dist-info/RECORD,,
+flock_core-0.4.0b22.dist-info/METADATA,sha256=oV2HF6qAqxnneQoXA-vPHC1kDVw2FVb71g49Ru-IsxY,12970
+flock_core-0.4.0b22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.4.0b22.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.4.0b22.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.4.0b22.dist-info/RECORD,,