flock-core 0.4.513__py3-none-any.whl → 0.4.515__py3-none-any.whl

flock/core/execution/opik_executor.py

@@ -0,0 +1,103 @@
+# src/flock/core/execution/evaluation_processor.py
+"""Contains the EvaluationProcessor class responsible for evaluating Flock agents
+against datasets using various metrics.
+"""
+
+from pathlib import Path
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Union,
+)
+
+from opik import Opik
+from pandas import DataFrame
+
+# Conditional pandas import
+try:
+    import pandas as pd
+
+    PANDAS_AVAILABLE = True
+except ImportError:
+    pd = None  # type: ignore
+    PANDAS_AVAILABLE = False
+
+# Box for results
+from datasets import Dataset as HFDataset
+
+from flock.core.evaluation.utils import (
+    normalize_dataset,
+    # Import metric calculation/aggregation helpers
+)
+
+# Flock core imports
+from flock.core.logging.logging import get_logger
+
+if TYPE_CHECKING:
+    from flock.core.flock import Flock
+    from flock.core.flock_agent import FlockAgent
+    # Conditional types
+
+
+logger = get_logger("execution.opik")
+
+
+class OpikExecutor:
+    """Handles the evaluation of Flock agents against datasets."""
+
+    def __init__(self, flock_instance: "Flock"):
+        """Initializes the EvaluationProcessor.
+
+        Args:
+            flock_instance: The Flock instance this processor will use.
+        """
+        self.flock = flock_instance
+
+    async def evaluate_with_opik(
+        self,
+        dataset: str | Path | list[dict[str, Any]] | DataFrame | HFDataset,
+        start_agent: Union["FlockAgent", str],
+        input_mapping: dict[str, str],
+        answer_mapping: dict[str, str],) -> DataFrame | list[dict[str, Any]]:
+        """Evaluates the Flock's performance against a dataset asynchronously."""
+        logger.info(f"Evaluating Flock's performance against dataset: {dataset}")
+
+        # Evaluation task
+        def evaluation_task(dataset_item):
+          flock_result = self.flock.run(start_agent=start_agent, input=dataset_item, box_result=False)
+
+          result = {
+              "input": dataset_item.get("test"),
+              "output": flock_result.get("answer"),
+              "context": ["placeholder string"]
+          }
+
+          return result
+
+        start_agent_name = (
+            start_agent.name if hasattr(start_agent, "name") else start_agent
+        )
+        dataset_name = str(dataset)
+
+        # --- 1. Normalize Dataset ---
+        try:
+            df = normalize_dataset(dataset)  # Uses helper
+            if df is None or df.empty:
+                raise ValueError(
+                    "Provided dataset is empty or could not be normalized."
+                )
+            logger.info(f"Normalized dataset with {len(df)} items.")
+        except Exception as e:
+            logger.error(
+                f"Failed to load or normalize dataset: {e}", exc_info=True
+            )
+            raise ValueError(f"Dataset processing failed: {e}") from e
+
+        logger.info(f"type(df): {type(df)}")        # ➜ <class 'pandas.core.frame.DataFrame'>
+        logger.info(f"df.shape: {df.shape}")        # e.g. (123456, N_COLUMNS+2)
+        logger.info(f"df['split'].value_counts(): {df['split'].value_counts()}")
+        logger.info(f"df['config'].unique(): {df['config'].unique()}")
+        client = Opik()
+        dataset = client.get_or_create_dataset(name=dataset_name)
+        dataset.insert_from_pandas(dataframe=df, ignore_keys=["source"])
+        logger.info(f"Imported dataset to Opik")

flock/core/flock_factory.py

@@ -472,7 +472,6 @@ class FlockFactory:
         schedule_expression: str, # e.g., "every 1h", "0 0 * * *"
         description: str | Callable[..., str] | None = None,
         model: str | Callable[..., str] | None = None,
-        input: SignatureType = None, # Input might be implicit or none
         output: SignatureType = None, # Input might be implicit or none
         tools: list[Callable[..., Any] | Any] | None = None,
         servers: list[str | FlockMCPServerBase] | None = None,
@@ -496,7 +495,7 @@ class FlockFactory:
             name=name,
             description=description,
             model=model,
-            input=input + ", trigger_time: str | Time of scheduled execution",
+            input="trigger_time: str | Time of scheduled execution",
             output=output,
             tools=tools,
             servers=servers,

flock/core/interpreter/python_interpreter.py

@@ -37,6 +37,14 @@ class InterpreterError(ValueError):
 
     pass
 
+class BreakException(Exception):
+    """Signal a 'break' from the simulated loop."""
+    pass
+
+class ContinueException(Exception):
+    """Signal a 'continue' in the simulated loop."""
+    pass
+
 
 class PythonInterpreter:
     r"""A customized python interpreter to control the execution of
@@ -44,8 +52,6 @@ class PythonInterpreter:
     functions given in action space and import white list. It also supports
     fuzzy variable matching to receive uncertain input variable name.
 
-    [Documentation omitted for brevity]
-
     Args:
         action_space (Dict[str, Any]): A dictionary mapping action names to
             their corresponding functions or objects.
@@ -76,6 +82,9 @@ class PythonInterpreter:
             "enum",
             "json",
             "ast",
+            "numpy",
+            "sympy",
+            "pandas",
         ]  # default imports
         self.verbose = verbose
 
@@ -95,50 +104,57 @@ class PythonInterpreter:
 
         [Documentation omitted for brevity]
         """
-        if state is not None:
-            self.state.update(state)
-        if fuzz_state is not None:
-            self.fuzz_state.update(fuzz_state)
-
         try:
-            expression = ast.parse(code)
-        except SyntaxError as e:
-            error_line = code.splitlines()[e.lineno - 1]
-            raise InterpreterError(
-                f"Syntax error in code at line {e.lineno}: {error_line}\nError: {e}"
-            )
+            if state is not None:
+                self.state.update(state)
+            if fuzz_state is not None:
+                self.fuzz_state.update(fuzz_state)
 
-        result = None
-        if self.verbose:
-            self.log("[Interpreter] Starting code execution...")
+            try:
+                expression = ast.parse(code)
+            except SyntaxError as e:
+                error_line = code.splitlines()[e.lineno - 1]
+                self.log(
+                    f"[Interpreter] Syntax error in code at line {e.lineno}: {error_line}\nError: {e}")
+                return(
+                    f"Syntax error in code at line {e.lineno}: {error_line}\nError: {e}"
+                )
 
-        for idx, node in enumerate(expression.body):
-            # Log the AST node being executed (using unparse if available)
+            result = None
             if self.verbose:
-                try:
-                    node_repr = ast.unparse(node)
-                except Exception:
-                    node_repr = ast.dump(node)
-                self.log(f"[Interpreter] Executing node {idx}: {node_repr}")
+                self.log("[Interpreter] Starting code execution...")
 
-            try:
-                line_result = self._execute_ast(node)
-            except InterpreterError as e:
-                if not keep_state:
-                    self.clear_state()
-                msg = f"Evaluation of the code stopped at node {idx}. See:\n{e}"
-                raise InterpreterError(msg)
-            if line_result is not None:
-                result = line_result
+            for idx, node in enumerate(expression.body):
+                # Log the AST node being executed (using unparse if available)
                 if self.verbose:
-                    self.log(f"[Interpreter] Node {idx} result: {result}")
+                    try:
+                        node_repr = ast.unparse(node)
+                    except Exception:
+                        node_repr = ast.dump(node)
+                    self.log(f"[Interpreter] Executing node {idx}: {node_repr}")
 
-        if self.verbose:
-            self.log("[Interpreter] Finished code execution.")
-        if not keep_state:
-            self.clear_state()
+                try:
+                    line_result = self._execute_ast(node)
+                except InterpreterError as e:
+                    if not keep_state:
+                        self.clear_state()
+                    msg = f"Evaluation of the code stopped at node {idx}. See:\n{e}"
+                    return msg
+                if line_result is not None:
+                    result = line_result
+                    if self.verbose:
+                        self.log(f"[Interpreter] Node {idx} result: {result}")
 
-        return result
+            if self.verbose:
+                self.log("[Interpreter] Finished code execution.")
+            if not keep_state:
+                self.clear_state()
+
+            return result
+        except Exception as e:
+            self.log(
+                f"[Interpreter] Error during code execution: {e}")
+            return f"[Interpreter] Error during code execution: {e}"
 
     def clear_state(self) -> None:
         r"""Initialize :obj:`state` and :obj:`fuzz_state`"""
@@ -236,7 +252,7 @@ class PythonInterpreter:
         elif isinstance(expression, ast.Assert):
             return self._execute_assert(expression)
         else:
-            raise InterpreterError(
+            return(
                 f"{expression.__class__.__name__} is not supported."
             )
 
@@ -253,17 +269,17 @@ class PythonInterpreter:
             self.state[target.id] = value
         elif isinstance(target, ast.Tuple):
             if not isinstance(value, tuple):
-                raise InterpreterError(
+                return(
                     f"Expected type tuple, but got {value.__class__.__name__} instead."
                 )
             if len(target.elts) != len(value):
-                raise InterpreterError(
+                return(
                     f"Expected {len(target.elts)} values but got {len(value)}."
                 )
             for t, v in zip(target.elts, value):
                 self.state[self._execute_ast(t)] = v
         else:
-            raise InterpreterError(
+            return(
                 f"Unsupported variable type. Expected ast.Name or ast.Tuple, got {target.__class__.__name__} instead."
             )
 
@@ -297,7 +313,7 @@ class PythonInterpreter:
             isinstance(current_value, (int, float))
             and isinstance(increment_value, (int, float))
         ):
-            raise InterpreterError(
+            return(
                 f"Invalid types for augmented assignment: {type(current_value)}, {type(increment_value)}"
             )
         if isinstance(augassign.op, ast.Add):
@@ -309,7 +325,7 @@ class PythonInterpreter:
         elif isinstance(augassign.op, ast.Div):
             new_value = current_value / increment_value
         else:
-            raise InterpreterError(
+            return(
                 f"Augmented assignment operator {augassign.op} is not supported"
             )
         self._assign(augassign.target, new_value)
@@ -319,7 +335,7 @@ class PythonInterpreter:
         index = self._execute_ast(subscript.slice)
         value = self._execute_ast(subscript.value)
         if not isinstance(subscript.ctx, ast.Load):
-            raise InterpreterError(
+            return(
                 f"{subscript.ctx.__class__.__name__} is not supported for subscript."
             )
         if isinstance(value, (list, tuple)):
@@ -330,7 +346,7 @@ class PythonInterpreter:
             close_matches = difflib.get_close_matches(index, list(value.keys()))
             if len(close_matches) > 0:
                 return value[close_matches[0]]
-        raise InterpreterError(f"Could not index {value} with '{index}'.")
+        return(f"Could not index {value} with '{index}'.")
 
     def _execute_name(self, name: ast.Name):
         if name.id in dir(builtins):
@@ -340,7 +356,7 @@ class PythonInterpreter:
         elif isinstance(name.ctx, ast.Load):
             return self._get_value_from_state(name.id)
         else:
-            raise InterpreterError(f"{name.ctx} is not supported.")
+            return(f"{name.ctx} is not supported.")
 
     def _execute_condition(self, condition):
         if isinstance(condition, ast.BoolOp):
@@ -355,12 +371,12 @@ class PythonInterpreter:
                 ]
                 return any(results)
             else:
-                raise InterpreterError(
+                return(
                     f"Boolean operator {condition.op} is not supported"
                 )
         elif isinstance(condition, ast.Compare):
             if len(condition.ops) > 1:
-                raise InterpreterError(
+                return(
                     "Cannot evaluate conditions with multiple operators"
                 )
             left = self._execute_ast(condition.left)
@@ -387,7 +403,7 @@ class PythonInterpreter:
             elif isinstance(comparator, ast.NotIn):
                 return left not in right
             else:
-                raise InterpreterError("Unsupported comparison operator")
+                return("Unsupported comparison operator")
         elif isinstance(condition, ast.UnaryOp):
             return self._execute_unaryop(condition)
         elif isinstance(condition, ast.Name) or isinstance(condition, ast.Call):
@@ -395,7 +411,7 @@ class PythonInterpreter:
         elif isinstance(condition, ast.Constant):
             return bool(condition.value)
         else:
-            raise InterpreterError(
+            return(
                 f"Unsupported condition type: {type(condition).__name__}"
             )
 
@@ -428,7 +444,7 @@ class PythonInterpreter:
 
     def _execute_import_from(self, import_from: ast.ImportFrom):
         if import_from.module is None:
-            raise InterpreterError('"from . import" is not supported.')
+            return('"from . import" is not supported.')
         for import_name in import_from.names:
             full_name = import_from.module + f".{import_name.name}"
             self._validate_import(full_name)
@@ -440,12 +456,6 @@ class PythonInterpreter:
     # We keep both as provided, but you may wish to consolidate these in your code.
 
     def _execute_for(self, for_statement: ast.For):
-        class BreakException(Exception):
-            pass
-
-        class ContinueException(Exception):
-            pass
-
         result = None
         try:
             for value in self._execute_ast(for_statement.iter):
@@ -462,12 +472,6 @@ class PythonInterpreter:
         return result
 
     def _execute_while(self, while_statement: ast.While):
-        class BreakException(Exception):
-            pass
-
-        class ContinueException(Exception):
-            pass
-
         result = None
         try:
             while self._execute_condition(while_statement.test):
@@ -540,7 +544,7 @@ class PythonInterpreter:
                 found_name = True
                 return
         if not found_name:
-            raise InterpreterError(
+            return(
                 f"It is not permitted to import modules "
                 f"than module white list (try to import {full_name})."
             )
@@ -577,7 +581,7 @@ class PythonInterpreter:
         elif isinstance(operator, ast.MatMult):
             return left @ right
         else:
-            raise InterpreterError(f"Operator not supported: {operator}")
+            return(f"Operator not supported: {operator}")
 
     def _execute_unaryop(self, unaryop: ast.UnaryOp):
         operand = self._execute_ast(unaryop.operand)
@@ -592,31 +596,33 @@ class PythonInterpreter:
         elif isinstance(operator, ast.Invert):
             return ~operand
         else:
-            raise InterpreterError(f"Operator not supported: {operator}")
+            return(f"Operator not supported: {operator}")
 
     def _execute_listcomp(self, comp: ast.ListComp):
-        return [self._execute_comp(comp.elt, comp.generators)]
-
-    def _execute_dictcomp(self, comp: ast.DictComp):
-        return {
-            self._execute_comp(comp.key, comp.generators): self._execute_comp(
-                comp.value, comp.generators
-            )
-        }
+        return self._execute_comp(comp.elt, comp.generators)
 
     def _execute_setcomp(self, comp: ast.SetComp):
-        return {self._execute_comp(comp.elt, comp.generators)}
+        return set(self._execute_comp(comp.elt, comp.generators))
+
+    def _execute_dictcomp(self, comp: ast.DictComp):
+        keys   = self._execute_comp(comp.key,   comp.generators)
+        values = self._execute_comp(comp.value, comp.generators)
+        return dict(zip(keys, values))
 
     def _execute_comp(self, elt, generators):
+        # Base-case: wrap the single element in a list so that
+        # callers can safely .extend() it.
         if not generators:
-            return self._execute_ast(elt)
+            return [self._execute_ast(elt)]
+
         gen = generators[0]
-        result = []
+        acc: list[Any] = []
         for value in self._execute_ast(gen.iter):
             self._assign(gen.target, value)
             if all(self._execute_condition(if_cond) for if_cond in gen.ifs):
-                result.extend(self._execute_comp(elt, generators[1:]))
-        return result
+                acc.extend(self._execute_comp(elt, generators[1:]))
+        return acc
+
 
     def _execute_generatorexp(self, genexp: ast.GeneratorExp):
         def generator():
@@ -631,7 +637,7 @@ class PythonInterpreter:
         elif key in self.fuzz_state:
             return self.fuzz_state[key]
         else:
-            raise InterpreterError(f"The variable `{key}` is not defined.")
+            return(f"The variable `{key}` is not defined.")
 
 
 class TextPrompt(str):

flock/core/mixin/dspy_integration.py

@@ -9,7 +9,7 @@ from typing import Any, Literal
 from dspy import Tool
 
 from flock.core.logging.logging import get_logger
-from flock.core.util.spliter import split_top_level
+from flock.core.util.splitter import split_top_level
 
 # Import split_top_level (assuming it's moved or copied appropriately)
 # Option 1: If moved to a shared util

flock/core/util/input_resolver.py

@@ -1,7 +1,7 @@
 """Utility functions for resolving input keys to their corresponding values."""
 
 from flock.core.context.context import FlockContext
-from flock.core.util.spliter import split_top_level
+from flock.core.util.splitter import split_top_level
 
 
 def get_callable_members(obj):

flock/tools/code_tools.py

@@ -31,6 +31,30 @@ def code_evaluate_math(expression: str) -> float:
 
 @traced_and_logged
 def code_code_eval(python_code: str) -> str:
+    """A Python code evaluation tool that executes Python code and returns the result.
+    
+    The code may not be markdown-escaped with triple backticks.
+    It is expected to be a valid Python code snippet that can be executed directly.
+    The code is executed in a controlled environment with a limited set of libraries.
+    It allows the use of the following libraries:
+                "os",
+                "math",
+                "random",
+                "datetime",
+                "time",
+                "string",
+                "collections",
+                "itertools",
+                "functools",
+                "typing",
+                "enum",
+                "json",
+                "ast",
+                "numpy",
+                "sympy",
+                "pandas",
+                "httpx",
+    """
     try:
         result = PythonInterpreter(
             {},
@@ -48,9 +72,96 @@ def code_code_eval(python_code: str) -> str:
                 "enum",
                 "json",
                 "ast",
+                "numpy",
+                "sympy",
+                "pandas",
             ],
             verbose=True,
         ).execute(python_code)
         return result
     except Exception:
         raise
+
+
+@traced_and_logged
+def docker_code_execute(python_code: str) -> str:
+    """Execute Python code in a sandboxed Docker container."""
+    import ast
+    import os
+    import pathlib
+    import platform
+    import shutil
+    import textwrap
+    import uuid
+
+    import docker
+    def _auto_print_last_expr(code: str) -> str:
+        """If the last top-level statement is a bare expression,
+        append a print() so script mode surfaces its value.
+        """
+        tree = ast.parse(code, mode="exec")
+        if tree.body and isinstance(tree.body[-1], ast.Expr):
+            # Re-extract the exact source of that expression
+            expr_src = textwrap.dedent(
+                code.splitlines()[tree.body[-1].lineno - 1]
+            )
+            code += f"\nprint({expr_src})"
+        return code
+    # --- 1. Figure out a base directory that exists on this OS ----------
+    if platform.system() == "Windows":
+        base_dir = pathlib.Path(os.getenv("SANDBOX_BASE_DIR", r"C:\sandboxes"))
+    else:  # Linux, macOS, WSL2
+        base_dir = pathlib.Path(os.getenv("SANDBOX_BASE_DIR", "/var/sandboxes"))
+
+    base_dir.mkdir(parents=True, exist_ok=True)
+
+    sandbox_id = f"sbox-{uuid.uuid4()}"
+    workdir = base_dir / sandbox_id
+    workdir.mkdir(parents=True, exist_ok=False)
+
+    # Docker’s HTTP API always wants POSIX‐style paths (“/”, drive letter allowed).
+    host_path = workdir.resolve().as_posix()        # e.g. "C:/sandboxes/…"
+
+    client = docker.from_env()
+    image = "python:3.12-slim"
+
+    # --- 2. Decide whether we can / should request the gVisor runtime ---
+    runtime_args = {}
+    if platform.system() != "Windows" and shutil.which("runsc"):
+        runtime_args["runtime"] = "runsc"           # gVisor on Linux & macOS
+
+    container = client.containers.run(
+        image,
+        name=sandbox_id,
+        command=["sleep", "infinity"],
+        user="65534:65534",                # nobody
+        network_mode="none",
+        volumes={host_path: {"bind": "/workspace", "mode": "rw"}},
+        mem_limit="4g",
+        cpu_period=100_000,
+        cpu_quota=200_000,                 # 2 vCPU
+        security_opt=["no-new-privileges"],
+        detach=True,
+        **runtime_args,
+    )
+
+    try:
+        def exec_code(cmd: list[str], timeout: int = 30) -> str:
+            exec_id = client.api.exec_create(
+                container.id, cmd, workdir="/workspace"
+            )["Id"]
+            return client.api.exec_start(
+                exec_id, stream=False, demux=False, tty=False,
+            ).decode()
+
+        # --- 3. Copy code in and execute --------------------------------
+        (workdir / "main.py").write_text(_auto_print_last_expr(python_code), encoding="utf-8")
+        stdout = exec_code(["python", "main.py"], timeout=30)
+        return stdout.strip()
+
+    finally:
+        # --- 4. Tear everything down ------------------------------------
+        container.remove(force=True)
+        shutil.rmtree(workdir, ignore_errors=True)
+
+

flock/tools/file_tools.py

@@ -23,10 +23,19 @@ def file_get_anything_as_markdown(url_or_file_path: str):
         )
 
 
+@traced_and_logged
+def file_append_to_file(content: str, filename: str):
+    try:
+        with open(filename, "a", encoding="utf-8") as f:
+            f.write(content)
+    except Exception:
+        raise
+
+
 @traced_and_logged
 def file_save_to_file(content: str, filename: str):
     try:
-        with open(filename, "w") as f:
+        with open(filename, "w", encoding="utf-8") as f:
             f.write(content)
     except Exception:
         raise

flock/webapp/app/api/execution.py

@@ -20,7 +20,7 @@ if TYPE_CHECKING:
 from flock.core.logging.logging import (
     get_logger as get_flock_logger,  # For logging within the new endpoint
 )
-from flock.core.util.spliter import parse_schema
+from flock.core.util.splitter import parse_schema
 
 # Import the dependency to get the current Flock instance
 from flock.webapp.app.dependencies import (

flock/webapp/app/main.py

@@ -34,7 +34,7 @@ from flock.core.api.run_store import RunStore
 from flock.core.flock import Flock  # For type hinting
 from flock.core.flock_scheduler import FlockScheduler
 from flock.core.logging.logging import get_logger  # For logging
-from flock.core.util.spliter import parse_schema
+from flock.core.util.splitter import parse_schema
 
 # Import UI-specific routers
 from flock.webapp.app.api import (

{flock_core-0.4.513.dist-info → flock_core-0.4.515.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.4.513
+Version: 0.4.515
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -69,6 +69,7 @@ Provides-Extra: all-tools
 Requires-Dist: azure-identity>=1.23.0; extra == 'all-tools'
 Requires-Dist: azure-search-documents>=11.5.2; extra == 'all-tools'
 Requires-Dist: azure-storage-blob>=12.25.1; extra == 'all-tools'
+Requires-Dist: docker>=7.1.0; extra == 'all-tools'
 Requires-Dist: docling>=2.18.0; extra == 'all-tools'
 Requires-Dist: duckduckgo-search>=7.3.2; extra == 'all-tools'
 Requires-Dist: markdownify>=0.14.1; extra == 'all-tools'
@@ -83,6 +84,8 @@ Requires-Dist: docling>=2.18.0; extra == 'basic-tools'
 Requires-Dist: duckduckgo-search>=7.3.2; extra == 'basic-tools'
 Requires-Dist: markdownify>=0.14.1; extra == 'basic-tools'
 Requires-Dist: tavily-python>=0.5.0; extra == 'basic-tools'
+Provides-Extra: code-tools
+Requires-Dist: docker>=7.1.0; extra == 'code-tools'
 Provides-Extra: evaluation
 Requires-Dist: datasets>=3.2.0; extra == 'evaluation'
 Requires-Dist: rouge-score>=0.1.2; extra == 'evaluation'

{flock_core-0.4.513.dist-info → flock_core-0.4.515.dist-info}/RECORD

@@ -29,7 +29,7 @@ flock/core/__init__.py,sha256=juwyNr3QqKXUS5-E3hlMYRhgqHgQBqgtP12OF3tUCAI,1249
 flock/core/flock.py,sha256=iR4i0_z0w2ns_iHbP7FqN--7wlsPIWch1H-BVecPs_I,38205
 flock/core/flock_agent.py,sha256=Hl6TONSiJi2I-N_49-1hkW2q_hyPXMebMr-5oZLI-PY,48842
 flock/core/flock_evaluator.py,sha256=TPy6u6XX3cqkY1r9NW1w2lTwCMNW7pxhFYKLefnEbXg,1820
-flock/core/flock_factory.py,sha256=L3EFEUKqQmyxM_q0mh23ikLHPexSkV4Q8ifxIBSGA6s,18805
+flock/core/flock_factory.py,sha256=siCShld0mHPzjsw2_TUhg_nesMYhocJympt1M8ch6p8,18724
 flock/core/flock_module.py,sha256=ObILimpVaPnaaqYvcBYJJ20lQzfrjgTdADplaNRjHU0,7448
 flock/core/flock_registry.py,sha256=KzdFfc3QC-Dk42G24hdf6Prp3HvGj9ymXR3TTBe-T-A,27161
 flock/core/flock_router.py,sha256=1OAXDsdaIIFApEfo6SRfFEDoTuGt3Si7n2MXiySEfis,2644
@@ -52,8 +52,9 @@ flock/core/evaluation/utils.py,sha256=S5M0uTFcClphZsR5EylEzrRNK-1434yImiGYL4pR_5
 flock/core/execution/batch_executor.py,sha256=mHwCI-DHqApCv_EVCN0ZOUd-LCQLjREpxKbAUPC0pcY,15266
 flock/core/execution/evaluation_executor.py,sha256=D9EO0sU-2qWj3vomjmUUi-DOtHNJNFRf30kGDHuzREE,17702
 flock/core/execution/local_executor.py,sha256=rnIQvaJOs6zZORUcR3vvyS6LPREDJTjaygl_Db0M8ao,952
+flock/core/execution/opik_executor.py,sha256=tl2Ti9NM_9WtcjXvJ0c7up-syRNq_OsLmiuYWqkGV4k,3325
 flock/core/execution/temporal_executor.py,sha256=dHcb0xuzPFWU_wbwTgI7glLNyyppei93Txs2sapjhaw,6283
-flock/core/interpreter/python_interpreter.py,sha256=RaUMZuufsKBNQ4FAeSaOgUuxzs8VYu5TgUUs-xwaxxM,26376
+flock/core/interpreter/python_interpreter.py,sha256=4-wRsxC6-gToEdRr_pp-n2idWwe_Y2zN0o3TbzUPhy0,26632
 flock/core/logging/__init__.py,sha256=xn5fC-8IgsdIv0ywe_cICK1KVhTrVD8t-jYORg0ETUA,155
 flock/core/logging/logging.py,sha256=VyBsin-3q8UQ0DY-K72t8FtrGJQbUwIfzxaC7rIWMvQ,19820
 flock/core/logging/telemetry.py,sha256=Trssqx02SBovTL843YwY3L-ZGj3KvcfMHLMU7Syk8L0,6561
@@ -79,7 +80,7 @@ flock/core/mcp/types/handlers.py,sha256=VEpOx5ShvlvOEvgo2Fs5rql-x0obVQYgEpcb8FBr
 flock/core/mcp/types/types.py,sha256=2amE-oastGe1GGVI4gbH2ltCX7QvYnJebSArATvttUU,11410
 flock/core/mcp/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flock/core/mcp/util/helpers.py,sha256=Xlf4iKW_lZxsVMTRoOnV29JsJfAppfmEJrb6sIcoCH4,636
-flock/core/mixin/dspy_integration.py,sha256=LQN4cfcG6Myi6kX0-2bKCuK1K_k_lu3SNaTdHHk3lEU,17745
+flock/core/mixin/dspy_integration.py,sha256=rsZ9bkCKlT3jJRncnwwngTtffKcF2WloFvSleaZ0QRk,17746
 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
@@ -91,9 +92,9 @@ flock/core/serialization/serialization_utils.py,sha256=AHRf90trgnj2Q6aaGaq5eja5P
 flock/core/util/cli_helper.py,sha256=9MiAw8y0IRlWKF7lRYViRFzSwbWSeiiLv0usyhn8XlU,49966
 flock/core/util/file_path_utils.py,sha256=Odf7uU32C-x1KNighbNERSiMtkzW4h8laABIoFK7A5M,6246
 flock/core/util/hydrator.py,sha256=ARg4ufXNlfAESDaxPeU8j6TOJ2ywzfl00KAIfVHGIxo,10699
-flock/core/util/input_resolver.py,sha256=KPoPSpklyCoiR2t5r6J6GJHegmPLFZ0YE126VcKBewM,4703
+flock/core/util/input_resolver.py,sha256=QE3EjP7xTRNHuH6o77O3YhlhiCWOcnDg8cnSXzngKnM,4704
 flock/core/util/loader.py,sha256=j3q2qem5bFMP2SmMuYjb-ISxsNGNZd1baQmpvAnRUUk,2244
-flock/core/util/spliter.py,sha256=rDLnZX158PWkmW8vi2UfMLAMRXcHQFUIydAABd-lDGw,7154
+flock/core/util/splitter.py,sha256=rDLnZX158PWkmW8vi2UfMLAMRXcHQFUIydAABd-lDGw,7154
 flock/evaluators/__init__.py,sha256=Y0cEkx0dujRmy--TDpKoTqFSLzbyFz8BwEOv8kdSUhg,22
 flock/evaluators/declarative/__init__.py,sha256=Y0cEkx0dujRmy--TDpKoTqFSLzbyFz8BwEOv8kdSUhg,22
 flock/evaluators/declarative/declarative_evaluator.py,sha256=tulTpUOXhF-wMe5a9ULpsCiS1o2Z-DOXOUTqOSzVYqI,7397
@@ -480,8 +481,8 @@ flock/themes/zenwritten-dark.toml,sha256=To5l6520_3UqAGiEumpzGWsHhXxqu9ThrMildXK
 flock/themes/zenwritten-light.toml,sha256=G1iEheCPfBNsMTGaVpEVpDzYBHA_T-MV27rolUYolmE,1666
 flock/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flock/tools/azure_tools.py,sha256=OTJsb0B4l70GcD1W3ZMDHWd3X8nEnszhhz2sllD2z9E,30187
-flock/tools/code_tools.py,sha256=CRDi3iIN4NQcgz4TJ4b-thFq7uXW_gIXPk-iEoWhF4E,1356
-flock/tools/file_tools.py,sha256=zbXo5SxyKYLvrE7k3vLF5tGxCeuaeJtCCdWQ1fXJMAA,4626
+flock/tools/code_tools.py,sha256=xLpuFl84y_GVzmIBe4qrr7h9wI3yWpM-M21GgEUjSjE,5247
+flock/tools/file_tools.py,sha256=VYjT942NqDMTnizHiF41O4Af6ySseSvahRNVVrGMXl8,4850
 flock/tools/github_tools.py,sha256=HH47-4K3HL6tRJhZhUttWDo2aloP9Hs12wRC_f_-Vkc,5329
 flock/tools/markdown_tools.py,sha256=94fjGAJ5DEutoioD0ke-YRbxF6IWJQKuPVBLkNqdBo4,6345
 flock/tools/system_tools.py,sha256=IUB8MiSxtQH5ZfTGOck3vl4TKva8m1lfU4-W5D5b-4w,202
@@ -494,13 +495,13 @@ flock/webapp/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 flock/webapp/app/chat.py,sha256=d5a_mr3H2nuWNFSpSlI_HyqX-J_4krndd4A-8S25EKM,28679
 flock/webapp/app/config.py,sha256=lqmneujnNZk-EFJV5cWpvxkqisxH3T3zT_YOI0JYThE,4809
 flock/webapp/app/dependencies.py,sha256=JUcwY1N6SZplU141lMN2wk9dOC9er5HCedrKTJN9wJk,5533
-flock/webapp/app/main.py,sha256=Clzfp1KeSe15jZzhna4Ung5hmQkdljT_0C-0RhU6rVw,57141
+flock/webapp/app/main.py,sha256=54DHCA4jaOBrW3Lly0t-r_gSOEBj96G4Izt5pkbFZSw,57142
 flock/webapp/app/models_ui.py,sha256=vrEBLbhEp6FziAgBSFOLT1M7ckwadsTdT7qus5_NduE,329
 flock/webapp/app/theme_mapper.py,sha256=QzWwLWpED78oYp3FjZ9zxv1KxCyj43m8MZ0fhfzz37w,34302
 flock/webapp/app/utils.py,sha256=RF8DMKKAj1XPmm4txUdo2OdswI1ATQ7cqUm6G9JFDzA,2942
 flock/webapp/app/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flock/webapp/app/api/agent_management.py,sha256=5xqO94QjjAYvxImyjKV9EGUQOvo4n3eqs7pGwGPSQJ4,10394
-flock/webapp/app/api/execution.py,sha256=sVBBaIQAt6xp9sorYdId3j6-2cuCCfe8-QbTZVfEGGw,12994
+flock/webapp/app/api/execution.py,sha256=wRuJ3v2PXgpyiPZ_0t4qYDG7tgQgBlAn1I9QZocQN2U,12995
 flock/webapp/app/api/flock_management.py,sha256=1o-6-36kTnUjI3am_BqLpdrcz0aqFXrxE-hQHIFcCsg,4869
 flock/webapp/app/api/registry_viewer.py,sha256=IoInxJiRR0yFlecG_l2_eRc6l35RQQyEDMG9BcBkipY,1020
 flock/webapp/app/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -560,8 +561,8 @@ flock/workflow/agent_execution_activity.py,sha256=Gy6FtuVAjf0NiUXmC3syS2eJpNQF4R
 flock/workflow/flock_workflow.py,sha256=iSUF_soFvWar0ffpkzE4irkDZRx0p4HnwmEBi_Ne2sY,9666
 flock/workflow/temporal_config.py,sha256=3_8O7SDEjMsSMXsWJBfnb6XTp0TFaz39uyzSlMTSF_I,3988
 flock/workflow/temporal_setup.py,sha256=YIHnSBntzOchHfMSh8hoLeNXrz3B1UbR14YrR6soM7A,1606
-flock_core-0.4.513.dist-info/METADATA,sha256=B1qPt_zjSDR-AT1CZrY4VxbYOa6s6DXdsW2LV_07OsY,22656
-flock_core-0.4.513.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.4.513.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.4.513.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.4.513.dist-info/RECORD,,
+flock_core-0.4.515.dist-info/METADATA,sha256=7nfOA03KGxxfxZ5-sm_GuTHXqhhD1NRxo_hvp6d8zBI,22786
+flock_core-0.4.515.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.4.515.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.4.515.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.4.515.dist-info/RECORD,,