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

flock/cli/utils.py

@@ -0,0 +1,135 @@
+# src/pilot_rules/collector/utils.py
+import datetime
+from pathlib import Path
+from typing import Any
+
+from rich import box
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import BarColumn, Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+
+# Create a shared console instance for consistent styling
+console = Console()
+
+
+def get_file_metadata(file_path: str) -> dict[str, Any]:
+    """Extract metadata from a file."""
+    metadata = {
+        "path": file_path,
+        "size_bytes": 0,
+        "line_count": 0,
+        "last_modified": "Unknown",
+        "created": "Unknown",
+    }
+
+    try:
+        p = Path(file_path)
+        stats = p.stat()
+        metadata["size_bytes"] = stats.st_size
+        metadata["last_modified"] = datetime.datetime.fromtimestamp(
+            stats.st_mtime
+        ).strftime("%Y-%m-%d %H:%M:%S")
+        # ctime is platform dependent (creation on Windows, metadata change on Unix)
+        # Use mtime as a reliable fallback for "created" if ctime is older than mtime
+        ctime = stats.st_ctime
+        mtime = stats.st_mtime
+        best_ctime = ctime if ctime <= mtime else mtime  # Heuristic
+        metadata["created"] = datetime.datetime.fromtimestamp(
+            best_ctime
+        ).strftime("%Y-%m-%d %H:%M:%S")
+
+        try:
+            # Attempt to read as text, fallback for binary or encoding issues
+            with p.open("r", encoding="utf-8", errors="ignore") as f:
+                content = f.read()
+                metadata["line_count"] = len(content.splitlines())
+        except (OSError, UnicodeDecodeError) as read_err:
+            # Handle cases where reading might fail (binary file, permissions etc.)
+            console.print(
+                f"[yellow]⚠ Warning:[/yellow] Could not read content/count lines for [cyan]{file_path}[/cyan]: [red]{read_err}[/red]"
+            )
+            metadata["line_count"] = 0  # Indicate unreadable or binary
+
+    except Exception as e:
+        console.print(
+            f"[yellow]⚠ Warning:[/yellow] Could not get complete metadata for [cyan]{file_path}[/cyan]: [red]{e}[/red]"
+        )
+
+    return metadata
+
+
+# --- Rich Formatting Utilities ---
+
+
+def print_header(title: str, style: str = "blue") -> None:
+    """Print a styled header with a panel."""
+    console.rule()
+    console.print(
+        Panel.fit(f"[bold {style}]{title}[/bold {style}]", border_style=style)
+    )
+
+
+def print_subheader(title: str, style: str = "cyan") -> None:
+    """Print a styled subheader."""
+    console.print(f"[bold {style}]== {title} ==[/bold {style}]")
+
+
+def print_success(message: str) -> None:
+    """Print a success message."""
+    console.print(f"[bold green]✓[/bold green] {message}")
+
+
+def print_error(message: str, exit_code: int | None = None) -> None:
+    """Print an error message and optionally exit."""
+    console.print(f"[bold red]✗ ERROR:[/bold red] {message}")
+    if exit_code is not None:
+        exit(exit_code)
+
+
+def print_warning(message: str) -> None:
+    """Print a warning message."""
+    console.print(f"[yellow]⚠ Warning:[/yellow] {message}")
+
+
+def create_progress() -> Progress:
+    """Create a standardized progress bar."""
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]{task.description}"),
+        BarColumn(complete_style="green", finished_style="green"),
+        TextColumn("[bold]{task.completed}/{task.total}"),
+        console=console,
+    )
+
+
+def create_task_table(title: str) -> Table:
+    """Create a standardized table for displaying task information."""
+    table = Table(
+        title=title, show_header=True, header_style="bold cyan", box=box.ROUNDED
+    )
+    return table
+
+
+def print_file_stats(files: list[str], title: str = "File Statistics") -> None:
+    """Print statistics about a list of files."""
+    if not files:
+        console.print("[yellow]No files found to display statistics.[/yellow]")
+        return
+
+    table = Table(title=title, show_header=True, header_style="bold magenta")
+    table.add_column("Statistic", style="cyan")
+    table.add_column("Value", style="green")
+
+    extensions = {Path(f).suffix.lower() for f in files if Path(f).suffix}
+    total_size = sum(get_file_metadata(f).get("size_bytes", 0) for f in files)
+    total_lines = sum(get_file_metadata(f).get("line_count", 0) for f in files)
+
+    table.add_row("Total Files", str(len(files)))
+    table.add_row("Total Size", f"{total_size / 1024:.2f} KB")
+    table.add_row("Total Lines", str(total_lines))
+    table.add_row(
+        "Extensions", ", ".join(sorted(extensions)) if extensions else "None"
+    )
+
+    console.print(table)

flock/core/flock.py

@@ -150,8 +150,7 @@ class Flock(BaseModel, Serializable):
                     )
 
         # Initialize console if needed for banner
-        if self.show_flock_banner:  # Use instance attribute
-            init_console()
+        init_console(clear_screen=True, show_banner=self.show_flock_banner)
 
         # Set Temporal debug environment variable
         self._set_temporal_debug_flag()
@@ -225,7 +224,7 @@ class Flock(BaseModel, Serializable):
             raise ValueError("Agent must have a name.")
 
         if agent.name in self._agents:
-            logger.warning(f"Agent '{agent.name}' already exists. Overwriting.")
+            raise ValueError("Agent with this name already exists.")
         self._agents[agent.name] = agent
         FlockRegistry.register_agent(agent)  # Register globally
 
@@ -351,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()
@@ -389,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:
@@ -410,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/flock_factory.py

@@ -38,6 +38,7 @@ class FlockFactory:
         print_context: bool = False,
         write_to_file: bool = False,
         stream: bool = False,
+        include_thought_process: bool = False,
     ) -> FlockAgent:
         """Creates a default FlockAgent.
 
@@ -52,6 +53,7 @@ class FlockFactory:
             max_tokens=max_tokens,
             temperature=temperature,
             stream=stream,
+            include_thought_process=include_thought_process,
         )
 
         evaluator = DeclarativeEvaluator(name="default", config=eval_config)

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__}"
@@ -336,16 +316,15 @@ class DSPyIntegrationMixin:
     def _select_task(
         self,
         signature: Any,
-        agent_type_override: AgentType,
+        override_evaluator_type: AgentType,
         tools: list[Any] | None = None,
+        kwargs: dict[str, Any] = {},
     ) -> Any:
         """Select and instantiate the appropriate DSPy Program/Module."""
         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 = []
@@ -360,13 +339,11 @@ class DSPyIntegrationMixin:
                     )
 
         dspy_program = None
-        selected_type = agent_type_override
+        selected_type = override_evaluator_type
 
         # 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)})"
@@ -374,11 +351,12 @@ class DSPyIntegrationMixin:
 
         try:
             if selected_type == "ChainOfThought":
-                dspy_program = dspy.ChainOfThought(signature)
+                dspy_program = dspy.ChainOfThought(signature, **kwargs)
             elif selected_type == "ReAct":
-                # ReAct requires tools, even if empty list
+                if not kwargs:
+                    kwargs = {"max_iters": 10}
                 dspy_program = dspy.ReAct(
-                    signature, tools=processed_tools or [], max_iters=10
+                    signature, tools=processed_tools or [], **kwargs
                 )
             elif selected_type == "Predict":  # Default or explicitly Completion
                 dspy_program = dspy.Predict(signature)
@@ -388,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(
@@ -401,8 +377,10 @@ class DSPyIntegrationMixin:
 
     def _process_result(
         self, result: Any, inputs: dict[str, Any]
-    ) -> dict[str, Any]:
+    ) -> tuple[dict[str, Any], float, list]:
         """Convert the DSPy result object to a dictionary."""
+        import dspy
+
         if result is None:
             logger.warning("DSPy program returned None result.")
             return {}
@@ -412,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)
@@ -429,7 +405,12 @@ class DSPyIntegrationMixin:
             logger.debug(f"Processed DSPy result to dict: {output_dict}")
             # Optionally merge inputs back if desired (can make result dict large)
             final_result = {**inputs, **output_dict}
-            return final_result
+
+            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()
+
+            return final_result, cost, lm_history
 
         except Exception as conv_error:
             logger.error(

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

@@ -43,7 +43,7 @@ def display_hummingbird():
 """)
 
 
-def init_console(clear_screen: bool = True):
+def init_console(clear_screen: bool = True, show_banner: bool = True):
     """Display the Flock banner."""
     banner_text = Text(
         f"""
@@ -60,16 +60,18 @@ def init_console(clear_screen: bool = True):
     )
     if clear_screen:
         console.clear()
-    console.print(banner_text)
+
+    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"""
+        """
 🦆    🐓     🐤     🐧
 ╭━━━━━━━━━━━━━━━━━━━━━━━━╮
 │ ▒█▀▀▀ █░░ █▀▀█ █▀▀ █░█ │
@@ -82,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

@@ -19,7 +19,7 @@ logger = get_logger("evaluators.declarative")
 class DeclarativeEvaluatorConfig(FlockEvaluatorConfig):
     """Configuration for the DeclarativeEvaluator."""
 
-    agent_type_override: str | None = None
+    override_evaluator_type: str | None = None
     model: str | None = "openai/gpt-4o"
     use_cache: bool = True
     temperature: float = 0.0
@@ -28,11 +28,14 @@ class DeclarativeEvaluatorConfig(FlockEvaluatorConfig):
         default=False,
         description="Enable streaming output from the underlying DSPy program.",
     )
+    include_thought_process: bool = Field(
+        default=False,
+        description="Include the thought process in the output.",
+    )
+    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(
@@ -40,6 +43,9 @@ class DeclarativeEvaluator(
         description="Evaluator configuration",
     )
 
+    cost: float = 0.0
+    lm_history: list = Field(default_factory=list)
+
     async def evaluate(
         self, agent: FlockAgent, inputs: dict[str, Any], tools: list[Any]
     ) -> dict[str, Any]:
@@ -68,8 +74,9 @@ class DeclarativeEvaluator(
             )
             agent_task = self._select_task(
                 _dspy_signature,
-                agent_type_override=self.config.agent_type_override,
+                override_evaluator_type=self.config.override_evaluator_type,
                 tools=tools,
+                kwargs=self.config.kwargs,
             )
         except Exception as setup_error:
             logger.error(
@@ -82,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)
@@ -109,21 +112,42 @@ class DeclarativeEvaluator(
                 if delta_content:
                     console.print(delta_content, end="")
 
-                result_dict = self._process_result(chunk, inputs)
+                result_dict, cost, lm_history = self._process_result(chunk, inputs)
+                self.cost = cost
+                self.lm_history = lm_history
 
             console.print("\n")
-            return result_dict
+            return self.filter_thought_process(
+                result_dict, self.config.include_thought_process
+            )
 
         else:  # Non-streaming path
             logger.info(f"Evaluating agent '{agent.name}' without streaming.")
             try:
                 # Ensure the call is awaited if the underlying task is async
                 result_obj = agent_task(**inputs)
-                result_dict = self._process_result(result_obj, inputs)
-                return result_dict
+                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
+                )
             except Exception as e:
                 logger.error(
                     f"Error during non-streaming evaluation for agent '{agent.name}': {e}",
                     exc_info=True,
                 )
                 raise RuntimeError(f"Evaluation failed: {e}") from e
+
+    def filter_thought_process(
+        result_dict: dict[str, Any], include_thought_process: bool
+    ) -> dict[str, Any]:
+        """Filter out thought process from the result dictionary."""
+        if include_thought_process:
+            return result_dict
+        else:
+            return {
+                k: v
+                for k, v in result_dict.items()
+                if not (k.startswith("reasoning") or k.startswith("trajectory"))
+            }

flock/modules/output/output_module.py

@@ -0,0 +1,194 @@
+"""Output formatting and display functionality for agents."""
+
+from typing import TYPE_CHECKING, Any
+
+from pydantic import Field
+
+from flock.core.context.context_vars import FLOCK_BATCH_SILENT_MODE
+
+if TYPE_CHECKING:
+    from flock.core import FlockAgent
+
+from flock.core.context.context import FlockContext
+from flock.core.flock_module import FlockModule, FlockModuleConfig
+from flock.core.logging.formatters.themed_formatter import (
+    ThemedAgentResultFormatter,
+)
+from flock.core.logging.formatters.themes import OutputTheme
+from flock.core.logging.logging import get_logger
+
+# from flock.core.logging.formatters.themes import OutputTheme
+# from flock.core.logging.logging import get_logger
+# from flock.core.serialization.json_encoder import FlockJSONEncoder
+
+logger = get_logger("module.output")
+
+
+class OutputModuleConfig(FlockModuleConfig):
+    """Configuration for output formatting and display."""
+
+    theme: OutputTheme = Field(
+        default=OutputTheme.afterglow, description="Theme for output formatting"
+    )
+    render_table: bool = Field(
+        default=False, description="Whether to render output as a table"
+    )
+    max_length: int = Field(
+        default=1000, description="Maximum length for displayed output"
+    )
+    truncate_long_values: bool = Field(
+        default=True, description="Whether to truncate long values in display"
+    )
+    show_metadata: bool = Field(
+        default=True, description="Whether to show metadata like timestamps"
+    )
+    format_code_blocks: bool = Field(
+        default=True,
+        description="Whether to apply syntax highlighting to code blocks",
+    )
+    custom_formatters: dict[str, str] = Field(
+        default_factory=dict,
+        description="Custom formatters for specific output types",
+    )
+    no_output: bool = Field(
+        default=False,
+        description="Whether to suppress output",
+    )
+    print_context: bool = Field(
+        default=False,
+        description="Whether to print the context",
+    )
+
+
+class OutputModule(FlockModule):
+    """Module that handles output formatting and display."""
+
+    name: str = "output"
+    config: OutputModuleConfig = Field(
+        default_factory=OutputModuleConfig, description="Output configuration"
+    )
+
+    def __init__(self, name: str, config: OutputModuleConfig):
+        super().__init__(name=name, config=config)
+        self._formatter = ThemedAgentResultFormatter(
+            theme=self.config.theme,
+            max_length=self.config.max_length,
+            render_table=self.config.render_table,
+        )
+
+    def _format_value(self, value: Any, key: str) -> str:
+        """Format a single value based on its type and configuration."""
+        # Check for custom formatter
+        if key in self.config.custom_formatters:
+            formatter_name = self.config.custom_formatters[key]
+            if hasattr(self, f"_format_{formatter_name}"):
+                return getattr(self, f"_format_{formatter_name}")(value)
+
+        # Default formatting based on type
+        if isinstance(value, dict):
+            return self._format_dict(value)
+        elif isinstance(value, list):
+            return self._format_list(value)
+        elif isinstance(value, str) and self.config.format_code_blocks:
+            return self._format_potential_code(value)
+        else:
+            return str(value)
+
+    def _format_dict(self, d: dict[str, Any], indent: int = 0) -> str:
+        """Format a dictionary with proper indentation."""
+        lines = []
+        for k, v in d.items():
+            formatted_value = self._format_value(v, k)
+            if (
+                self.config.truncate_long_values
+                and len(formatted_value) > self.config.max_length
+            ):
+                formatted_value = (
+                    formatted_value[: self.config.max_length] + "..."
+                )
+            lines.append(f"{'  ' * indent}{k}: {formatted_value}")
+        return "\n".join(lines)
+
+    def _format_list(self, lst: list[Any]) -> str:
+        """Format a list with proper indentation."""
+        return "\n".join(f"- {self._format_value(item, '')}" for item in lst)
+
+    def _format_potential_code(self, text: str) -> str:
+        """Format text that might contain code blocks."""
+        import re
+
+        def replace_code_block(match):
+            code = match.group(2)
+            lang = match.group(1) if match.group(1) else ""
+            # Here you could add syntax highlighting
+            return f"```{lang}\n{code}\n```"
+
+        # Replace code blocks with formatted versions
+        text = re.sub(
+            r"```(\w+)?\n(.*?)\n```", replace_code_block, text, flags=re.DOTALL
+        )
+        return text
+
+    async def post_evaluate(
+        self,
+        agent: "FlockAgent",
+        inputs: dict[str, Any],
+        result: dict[str, Any],
+        context: FlockContext | None = None,
+    ) -> dict[str, Any]:
+        """Format and display the output."""
+        logger.debug("Formatting and displaying output")
+
+        # Determine if output should be suppressed
+        is_silent = self.config.no_output or (
+            context and context.get_variable(FLOCK_BATCH_SILENT_MODE, False)
+        )
+
+        if is_silent:
+            logger.debug("Output suppressed (config or batch silent mode).")
+            return result  # Skip console output
+
+        logger.debug("Formatting and displaying output to console.")
+
+        if self.config.print_context and context:
+            # Add context snapshot if requested (be careful with large contexts)
+            try:
+                # Create a copy or select relevant parts to avoid modifying original result dict directly
+                display_result = result.copy()
+                display_result["context_snapshot"] = (
+                    context.to_dict()
+                )  # Potential performance hit
+            except Exception:
+                display_result = result.copy()
+                display_result["context_snapshot"] = (
+                    "[Error serializing context]"
+                )
+            result_to_display = display_result
+        else:
+            result_to_display = result
+
+        if not hasattr(self, "_formatter") or self._formatter is None:
+            self._formatter = ThemedAgentResultFormatter(
+                theme=self.config.theme,
+                max_length=self.config.max_length,
+                render_table=self.config.render_table,
+                wait_for_input=self.config.wait_for_input,
+            )
+        self._formatter.display_result(result_to_display, agent.name)
+
+        return result  # Return the original, unmodified result
+
+    def update_theme(self, new_theme: OutputTheme) -> None:
+        """Update the output theme."""
+        self.config.theme = new_theme
+        self._formatter = ThemedAgentResultFormatter(
+            theme=self.config.theme,
+            max_length=self.config.max_length,
+            render_table=self.config.render_table,
+            wait_for_input=self.config.wait_for_input,
+            write_to_file=self.config.write_to_file,
+        )
+
+    def add_custom_formatter(self, key: str, formatter_name: str) -> None:
+        """Add a custom formatter for a specific output key."""
+        self.config.custom_formatters[key] = formatter_name

{flock_core-0.4.0b19.dist-info → flock_core-0.4.0b21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.0b19
+Version: 0.4.0b21
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -58,8 +58,6 @@ Requires-Dist: markdownify>=0.14.1; extra == 'tools'
 Requires-Dist: tavily-python>=0.5.0; extra == 'tools'
 Description-Content-Type: text/markdown
 
-# 🚀 Flock: The Declarative AI Agent Framework 🚀
-
 <p align="center">
   <!-- Placeholder for your Flock Logo/Banner - Replace URL -->
   <img alt="Flock Banner" src="https://raw.githubusercontent.com/whiteducksoftware/flock/master/docs/assets/images/flock.png" width="600">
@@ -95,20 +93,25 @@ Built with real-world deployment in mind, Flock integrates seamlessly with tools
 
 Flock offers a different way to build agentic systems:
 
-| Traditional Agent Frameworks 😟        | Flock Framework 🐤🐧🐓🦆             |
-| :------------------------------------- | :------------------------------------ |
-| 🤯 **Prompt Nightmare**                | ✅ **Declarative Simplicity**         |
-| *Long, brittle, hard-to-tune prompts*  | *Clear input/output specs (typed!)*   |
-| 💥 **Fragile & Unpredictable**         | ⚡ **Robust & Production-Ready**     |
-| *Single errors can halt everything*    | *Fault-tolerant via Temporal option*  |
-| 🧩 **Monolithic & Rigid**             | 🔧 **Modular & Flexible**             |
-| *Hard to extend or modify logic*       | *Pluggable Evaluators, Modules, Tools*|
-| ⛓️ **Basic Chaining**                 | 🚀 **Advanced Orchestration**         |
-| *Often just linear workflows*          | *Dynamic Routing, Batch Processing*   |
-| 🧪 **Difficult Testing**               | ✅ **Testable Components**            |
-| *Hard to unit test prompt logic*       | *Clear I/O contracts aid testing*     |
-| 📄 **Unstructured Output**             | ✨ **Structured Data Handling**       |
-| *Parsing unreliable LLM text output*   | *Native Pydantic/Typed Dict support*  |
+| Traditional Agent Frameworks 😟        | Flock Framework 🐤🐧🐓🦆                   |
+| :------------------------------------ | :------------------------------------- |
+| 🤯 **Prompt Nightmare**                | ✅ **Declarative Simplicity**           |
+| *Long, brittle, hard-to-tune prompts* | *Clear input/output specs (typed!)*    |
+| 💥 **Fragile & Unpredictable**         | ⚡ **Robust & Production-Ready**        |
+| *Single errors can halt everything*   | *Fault-tolerant via Temporal option*   |
+| 🧩 **Monolithic & Rigid**              | 🔧 **Modular & Flexible**               |
+| *Hard to extend or modify logic*      | *Pluggable Evaluators, Modules, Tools* |
+| ⛓️ **Basic Chaining**                  | 🚀 **Advanced Orchestration**           |
+| *Often just linear workflows*         | *Dynamic Routing, Batch Processing*    |
+| 🧪 **Difficult Testing**               | ✅ **Testable Components**              |
+| *Hard to unit test prompt logic*      | *Clear I/O contracts aid testing*      |
+| 📄 **Unstructured Output**             | ✨ **Structured Data Handling**         |
+| *Parsing unreliable LLM text output*  | *Native Pydantic/Typed Dict support*   |
+
+
+## 📹 Video Demo
+
+https://github.com/user-attachments/assets/bdab4786-d532-459f-806a-024727164dcc
 
 ## 💡 Core Concepts
 
@@ -210,7 +213,17 @@ if __name__ == "__main__":
         print("Ensure your LLM API key (e.g., OPENAI_API_KEY) is set in your .env file!")
 ```
 
-## ✨ Utility: @flockclass Hydrator
+## 🐤 New in Flock 0.4.0 `Magpie` 🐤
+
+### REST API - Deploy Flock Agents as REST API Endpoints
+
+### Web UI - Test Flock Agents in the Browser
+
+### CLI Tool - Manage Flock Agents via the Command Line
+
+### Serialization - Share, Deploy, and Run Flock Agents by human readable yaml files
+
+### ✨ Utility: @flockclass Hydrator
 
 Flock also provides conveniences. The @flockclass decorator allows you to easily populate Pydantic models using an LLM:
 
@@ -269,11 +282,10 @@ Ways to contribute:
 - Improve documentation.
 - Contribute new Modules, Evaluators, or Routers.
 - Add examples to the flock-showcase repository.
-- Join our Discord Community to discuss development! <!-- Add Discord link -->
 
 ## 📜 License
 
-Flock is licensed under the Apache License 2.0. See the LICENSE file for details.
+Flock is licensed under the MIT License. See the LICENSE file for details.
 
 ## 🏢 About
 

{flock_core-0.4.0b19.dist-info → flock_core-0.4.0b21.dist-info}/RECORD

@@ -14,14 +14,15 @@ flock/cli/manage_agents.py,sha256=Psl014LCrJmBgwrjsp7O3WNlWvQmVd_IDud3rd0lnLI,12
 flock/cli/registry_management.py,sha256=mAHy3wT97YgODR0gVOkTXDqR5NIPzM-E-z9dEtw9-tw,29790
 flock/cli/runner.py,sha256=TgiuhRLkpa6dn3C-3eCmWx-bWUlTjaH0sD7Y-O7MrYM,1122
 flock/cli/settings.py,sha256=Z_TXBzCYlCmSaKrJ_CQCdYy-Cj29gpI4kbC_2KzoKqg,27025
+flock/cli/utils.py,sha256=JJrvM-1D2tbWkicrtkhOgRqVqYb0MdA2XtHYGOYuPRw,4644
 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=g67jyWozK52ymqGEmYxMgXSkiL9ZpTXoDZMxwtWmRo4,25444
+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=qfeuAr6e028gbkxjj5jsq_HHqrWsmKHreJD6-QT8ets,2885
+flock/core/flock_factory.py,sha256=vLkCASLh7Vrb5NFjb4ZQT5xN3zsUDud51hAQxb82oTk,2993
 flock/core/flock_module.py,sha256=96aFVYAgwpKN53xGbivQDUpikOYGFCxK5mqhclOcxY0,3003
 flock/core/flock_registry.py,sha256=ekYpQgSkZVnbyPbl8gA7nf54brt94rYZZBe2RwEGtUc,20828
 flock/core/flock_router.py,sha256=A5GaxcGvtiFlRLHBTW7okh5RDm3BdKam2uXvRHRaj7k,2187
@@ -44,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
@@ -55,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=vlf6rJnR9EsfZi5KyFLEXIbUvhpBhodctn-mirYo7Pk,17382
+flock/core/mixin/dspy_integration.py,sha256=lB3VLBa5dnBJQOgdJCFGWC_0-XMyXmqCHmnCPFyrZuY,17197
 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
@@ -63,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=P3-lncS1J78MuPpDQ0D8qmfxMTCRxKkGdo9QRkzrp6A,49797
+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=j3xCEOhKHMvYtI43K2uqqJk068Lw94ch8GtWOmmJX7g,4803
+flock/evaluators/declarative/declarative_evaluator.py,sha256=nagYTKqoduQ968Pij4bZh0584RYH4MDPdYnh9dtaYHc,5905
 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
@@ -86,6 +87,7 @@ flock/modules/callback/callback_module.py,sha256=volGGgHtY19qj1wHR6m5a_hmXSbV3Ca
 flock/modules/memory/memory_module.py,sha256=bSkdFBW-Pp5ldHhXi8v4kfRM7zknfLR2fsOtbTosucI,14916
 flock/modules/memory/memory_parser.py,sha256=FLH7GL8XThvHiCMfX3eQH7Sz-f62fzhAUmO6_gaDI7U,4372
 flock/modules/memory/memory_storage.py,sha256=CNcLDMmvv0x7Z3YMKr6VveS_VCa7rKPw8l2d-XgqokA,27246
+flock/modules/output/output_module.py,sha256=tpNqkL8cB0cvikr1fmEJ-5E2SAeb-rYhht8IP90mEF0,7281
 flock/modules/performance/metrics_module.py,sha256=UD9OjY4-zAvauMD7YyDYqE1gyIhzpdr3JkBT8j9knxY,16790
 flock/modules/zep/zep_module.py,sha256=x7JG6O6xnwwum0RETIqKYbA3xzdcvX2aUuns0Cl0c2Q,6014
 flock/platform/docker_tools.py,sha256=fpA7-6rJBjPOUBLdQP4ny2QPgJ_042nmqRn5GtKnoYw,1445
@@ -439,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.0b19.dist-info/METADATA,sha256=AxxdPGiZnMvkFqmHKNmVLN4FH07NWjUSPXHGhamhF54,12697
-flock_core-0.4.0b19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.4.0b19.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.4.0b19.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.4.0b19.dist-info/RECORD,,
+flock_core-0.4.0b21.dist-info/METADATA,sha256=q4rcJrfPWmenOfchiag5UQhLaLmdr68TE-f7G6p7Hd8,12970
+flock_core-0.4.0b21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.4.0b21.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.4.0b21.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.4.0b21.dist-info/RECORD,,