flock-core 0.4.0b19__tar.gz → 0.4.0b21__tar.gz

{flock_core-0.4.0b19 → flock_core-0.4.0b21}/.gitignore

@@ -38,8 +38,7 @@ news/
 .chroma/
 hierarchical_memory/
 .repomix-output.txt
-output/
-!src/flock/modules/output/output_module.py
+
 .env.*
 .flock/
 

{flock_core-0.4.0b19 → flock_core-0.4.0b21}/PKG-INFO

@@ -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 → flock_core-0.4.0b21}/README.md

@@ -1,5 +1,3 @@
-# 🚀 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">
@@ -35,20 +33,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
 
@@ -150,7 +153,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:
 
@@ -209,11 +222,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 → flock_core-0.4.0b21}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "flock-core"
-version = "0.4.0b-19"
+version = "0.4.0b-21"
 description = "Declarative LLM Orchestration at Scale"
 readme = "README.md"
 authors = [

flock_core-0.4.0b21/src/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-0.4.0b19 → flock_core-0.4.0b21}/src/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-0.4.0b19 → flock_core-0.4.0b21}/src/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-0.4.0b19 → flock_core-0.4.0b21}/src/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-0.4.0b19 → flock_core-0.4.0b21}/src/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(