flock-core 0.4.0b19__py3-none-any.whl → 0.4.0b20__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
 

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/mixin/dspy_integration.py

@@ -336,8 +336,9 @@ 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:
@@ -360,7 +361,7 @@ class DSPyIntegrationMixin:
                     )
 
         dspy_program = None
-        selected_type = agent_type_override
+        selected_type = override_evaluator_type
 
         # Determine type if not overridden
         if not selected_type:
@@ -374,11 +375,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)
@@ -401,8 +403,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 {}
@@ -429,7 +433,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/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,7 +60,9 @@ 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"
     )

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,6 +28,11 @@ 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(
@@ -40,6 +45,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 +76,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(
@@ -109,21 +118,46 @@ 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.0b20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.0b19
+Version: 0.4.0b20
 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.0b20.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=K7EsY7K8avH57mJ3I_y0Ehlk0G8bYt4ZpBFYPtjgZ4o,25420
 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
@@ -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=MplWCkJZymtmf1646yUYlpBxaz39SOenW7EQ1SpSQnE,17681
 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
@@ -70,12 +71,12 @@ flock/core/tools/llm_tools.py,sha256=Bdt4Dpur5dGpxd2KFEQyxjfZazvW1HCDKY6ydMj6UgQ
 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=nbA3n7zpVopV7bDf_aB3HHRYXmIBSwT1yqpjiVl4r9g,49848
 flock/core/util/file_path_utils.py,sha256=Odf7uU32C-x1KNighbNERSiMtkzW4h8laABIoFK7A5M,6246
 flock/core/util/hydrator.py,sha256=z0kvqr4j3piExOb_T5EgATuNm77ZlqIKvLpt4PJusO8,10949
 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=Pi1GsQUGL8eJrl6GFWYpu7O9kXI11xIskdBVg08n8mo,6055
 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.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,,