flock-core 0.4.0b38__py3-none-any.whl → 0.4.0b40__py3-none-any.whl

flock/config.py

@@ -36,7 +36,9 @@ OTEL_FILE_NAME = config("OTEL_FILE_NAME", "flock_events.jsonl")
 OTEL_ENABLE_SQL: bool = config("OTEL_ENABLE_SQL", True) == "True"
 OTEL_ENABLE_FILE: bool = config("OTEL_ENABLE_FILE", True) == "True"
 OTEL_ENABLE_JAEGER: bool = config("OTEL_ENABLE_JAEGER", False) == "True"
-
+OTEL_ENABLE_OTLP: bool = config("OTEL_ENABLE_OTLP", False) == "True"
+OTEL_EXPORTER_OTLP_PROTOCOL: str = config("OTEL_EXPORTER_OTLP_PROTOCOL", "grpc")
+OTEL_EXPORTER_OTLP_ENDPOINT: str = config("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317")
 
 TELEMETRY = TelemetryConfig(
     OTEL_SERVICE_NAME,
@@ -48,4 +50,7 @@ TELEMETRY = TelemetryConfig(
     OTEL_ENABLE_JAEGER,
     OTEL_ENABLE_FILE,
     OTEL_ENABLE_SQL,
+    OTEL_ENABLE_OTLP,
+    OTEL_EXPORTER_OTLP_PROTOCOL,
+    OTEL_EXPORTER_OTLP_ENDPOINT,
 )

flock/core/api/custom_endpoint.py

@@ -0,0 +1,40 @@
+"""Lightweight helper object for declaring additional REST routes.
+
+Developers can pass instances of :class:`FlockEndpoint` to
+``Flock.start_api(custom_endpoints=[...])`` instead of the terse dictionary
+syntax.  The class carries optional Pydantic request/response models plus
+OpenAPI metadata so the generated docs look perfect.
+"""
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+
+from pydantic import BaseModel
+
+__all__ = [
+    "FlockEndpoint",
+]
+
+
+class FlockEndpoint(BaseModel):
+    """Declarative description of an extra API route."""
+
+    path: str
+    methods: list[str] = ["GET"]
+    callback: Callable[..., Any]
+
+    # Optional schema models
+    request_model: type[BaseModel] | None = None
+    response_model: type[BaseModel] | None = None
+
+    # OpenAPI / Swagger metadata
+    summary: str | None = None
+    description: str | None = None
+    name: str | None = None  # Route name in FastAPI
+    include_in_schema: bool = True
+
+    model_config = {
+        "arbitrary_types_allowed": True,
+        "validate_default": True,
+    }

flock/core/api/main.py

@@ -1,17 +1,22 @@
 # src/flock/core/api/main.py
 """Main Flock API server class and setup."""
 
-from typing import Any
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING, Any
 
 import uvicorn
 from fastapi import FastAPI
 from fastapi.responses import RedirectResponse
+from pydantic import BaseModel
 
 # Flock core imports
 from flock.core.api.models import FlockBatchRequest
-from flock.core.flock import Flock
 from flock.core.logging.logging import get_logger
 
+if TYPE_CHECKING:
+    # These imports are only for type hints
+    from flock.core.flock import Flock
+
 logger = get_logger("api.main")
 
 from .endpoints import create_api_router
@@ -63,14 +68,57 @@ except ImportError:
         def format_result_to_html(*args, **kwargs):
             return ""
 
+from flock.core.api.custom_endpoint import FlockEndpoint
 
-class FlockAPI:
-    """Coordinates the Flock API server, including endpoints and UI."""
 
-    def __init__(self, flock: Flock):
+class FlockAPI:
+    """Coordinates the Flock API server, including endpoints and UI.
+
+    A user can provide custom FastAPI-style routes via the ``custom_endpoints`` dict.
+    Each key is a tuple of ``(<path:str>, <methods:list[str] | None>)`` and the
+    value is a callback ``Callable``.  ``methods`` can be ``None`` or an empty
+    list to default to ``["GET"]``.  The callback can be synchronous or
+    ``async``.  At execution time we provide the following keyword arguments and
+    filter them to the callback's signature:
+
+    • ``body``   – request json/plain payload (for POST/PUT/PATCH)
+    • ``query``  – dict of query parameters
+    • ``flock``  – current :class:`Flock` instance
+    • any path parameters extracted from the route pattern
+    """
+
+    def __init__(
+        self,
+        flock: "Flock",
+        custom_endpoints: Sequence[FlockEndpoint] | dict[tuple[str, list[str] | None], Callable[..., Any]] | None = None,
+    ):
         self.flock = flock
+        # Normalize into list[FlockEndpoint]
+        self.custom_endpoints: list[FlockEndpoint] = []
+        if custom_endpoints:
+            merged: list[FlockEndpoint] = []
+            if isinstance(custom_endpoints, dict):
+                for (path, methods), cb in custom_endpoints.items():
+                    merged.append(
+                        FlockEndpoint(path=path, methods=list(methods) if methods else ["GET"], callback=cb)
+                    )
+            else:
+                merged.extend(list(custom_endpoints))
+
+            pending_endpoints = merged
+        else:
+            pending_endpoints = []
+
+        # FastAPI app instance
         self.app = FastAPI(title="Flock API")
-        self.run_store = RunStore()  # Create the run store instance
+
+        # Store run information
+        self.run_store = RunStore()
+
+        # Register any pending custom endpoints collected before app creation
+        if pending_endpoints:
+            self.custom_endpoints.extend(pending_endpoints)
+
         self._setup_routes()
 
     def _setup_routes(self):
@@ -81,6 +129,71 @@ class FlockAPI:
 
         # Root redirect (if UI is enabled later) will be added in start()
 
+        # --- Register user-supplied custom endpoints ---------------------
+        if self.custom_endpoints:
+            import inspect
+
+            from fastapi import Request
+
+            # Register any endpoints collected during __init__ (self.custom_endpoints)
+            if self.custom_endpoints:
+                from fastapi import Body
+
+                def _create_handler_factory(callback: Callable[..., Any], req_model: type[BaseModel] | None):
+
+                    if req_model is not None:
+
+                        async def _route_handler(body: req_model = Body(...), request: Request = None):  # type: ignore[arg-type,valid-type]
+                            payload: dict[str, Any] = {
+                                "body": body,
+                                "query": dict(request.query_params) if request else {},
+                                "flock": self.flock,
+                                **(request.path_params if request else {}),
+                            }
+
+                            sig = inspect.signature(callback)
+                            filtered_kwargs = {k: v for k, v in payload.items() if k in sig.parameters}
+
+                            if inspect.iscoroutinefunction(callback):
+                                return await callback(**filtered_kwargs)
+                            return callback(**filtered_kwargs)
+
+                    else:
+
+                        async def _route_handler(request: Request):
+                            payload: dict[str, Any] = {
+                                "query": dict(request.query_params),
+                                "flock": self.flock,
+                                **request.path_params,
+                            }
+
+                            if request.method in {"POST", "PUT", "PATCH"}:
+                                try:
+                                    payload["body"] = await request.json()
+                                except Exception:
+                                    payload["body"] = await request.body()
+
+                            sig = inspect.signature(callback)
+                            filtered_kwargs = {k: v for k, v in payload.items() if k in sig.parameters}
+
+                            if inspect.iscoroutinefunction(callback):
+                                return await callback(**filtered_kwargs)
+                            return callback(**filtered_kwargs)
+
+                    return _route_handler
+
+                for ep in self.custom_endpoints:
+                    self.app.add_api_route(
+                        ep.path,
+                        _create_handler_factory(ep.callback, ep.request_model),
+                        methods=ep.methods or ["GET"],
+                        name=ep.name or f"custom:{ep.path}",
+                        include_in_schema=ep.include_in_schema,
+                        response_model=ep.response_model,
+                        summary=ep.summary,
+                        description=ep.description,
+                    )
+
     # --- Core Execution Helper Methods ---
     # These remain here as they need access to self.flock and self.run_store
 
@@ -431,6 +544,7 @@ class FlockAPI:
         port: int = 8344,
         server_name: str = "Flock API",
         create_ui: bool = False,
+        #custom_endpoints: Sequence[FlockEndpoint] | dict[tuple[str, list[str] | None], Callable[..., Any]] | None = None,
     ):
         """Start the API server. If create_ui is True, it mounts the new webapp or the old FastHTML UI at the root."""
         if create_ui:

flock/core/api/runner.py

@@ -1,8 +1,10 @@
 # src/flock/api/runner.py
 """Provides functionality to start the Flock API server."""
 
-from typing import TYPE_CHECKING
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING, Any
 
+from flock.core.api.custom_endpoint import FlockEndpoint
 from flock.core.logging.logging import get_logger
 
 if TYPE_CHECKING:
@@ -17,6 +19,7 @@ def start_flock_api(
     port: int = 8344,
     server_name: str = "Flock API",
     create_ui: bool = False,
+    custom_endpoints: Sequence[FlockEndpoint] | dict[tuple[str, list[str] | None], Callable[..., Any]] | None = None,
 ) -> None:
     """Start a REST API server for the given Flock instance."""
     try:
@@ -32,7 +35,10 @@ def start_flock_api(
     logger.info(
         f"Preparing to start API server for Flock '{flock.name}' on {host}:{port} {'with UI' if create_ui else 'without UI'}"
     )
-    api_instance = FlockAPI(flock)  # Pass the Flock instance to the API
+    api_instance = FlockAPI(flock, custom_endpoints=custom_endpoints)  # Pass the Flock instance to the API
     api_instance.start(
-        host=host, port=port, server_name=server_name, create_ui=create_ui
+        host=host,
+        port=port,
+        server_name=server_name,
+        create_ui=create_ui,
     )

flock/core/execution/batch_executor.py

@@ -1,4 +1,5 @@
 import asyncio
+import concurrent.futures  # For real parallelism via threads
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
@@ -184,52 +185,77 @@ class BatchProcessor:
             )
             progress.start()
 
-        results = [None] * len(
-            prepared_batch_inputs
-        )  # Pre-allocate results list
-        tasks = []
-        semaphore = asyncio.Semaphore(
-            max_workers if parallel and not effective_use_temporal else 1
-        )  # Semaphore for parallel local
-
-        async def worker(index, item_inputs):
-            async with semaphore:
-                full_input = {**(static_inputs or {}), **item_inputs}
-                context = FlockContext()
-                context.set_variable(FLOCK_BATCH_SILENT_MODE, silent_mode)
-
-                run_desc = f"Batch item {index + 1}"
-                logger.debug(f"{run_desc} started.")
-                try:
-                    result = await self.flock.run_async(
-                        start_agent,
-                        full_input,
-                        box_result=box_results,
-                        context=context,
-                    )
-                    results[index] = result
-                    logger.debug(f"{run_desc} finished successfully.")
-                except Exception as e:
-                    logger.error(
-                        f"{run_desc} failed: {e}", exc_info=not return_errors
-                    )
-                    if return_errors:
-                        results[index] = e
-                    else:
-                        # If not returning errors, ensure the exception propagates
-                        # to stop asyncio.gather if running in parallel.
-                        if parallel and not effective_use_temporal:
-                            raise  # Re-raise to stop gather
-                        else:
-                            # For sequential, we just store None or the exception if return_errors=True
-                            # For Temporal, error handling happens within the workflow/activity usually
-                            results[index] = e if return_errors else None
-                finally:
-                    if progress_context:
-                        progress.update(
-                            progress_task_id, advance=1
-                        )  # Update progress
+        results = [None] * len(prepared_batch_inputs)  # Pre-allocate results list
+
+        # --- Worker Definitions ---
+        # We implement two flavours:
+        #   * async_worker: used for Temporal or sequential runs (keeps the original behaviour)
+        #   * thread_worker: executes the run in a dedicated thread via ThreadPoolExecutor for true parallelism.
+
+        async def async_worker(index: int, item_inputs: dict[str, Any]):
+            """Original coroutine worker used for non-threaded execution paths."""
+            full_input = {**(static_inputs or {}), **item_inputs}
+            context = FlockContext()
+            context.set_variable(FLOCK_BATCH_SILENT_MODE, silent_mode)
+
+            run_desc = f"Batch item {index + 1}"
+            logger.debug(f"{run_desc} started (async).")
+            try:
+                result = await self.flock.run_async(
+                    start_agent,
+                    full_input,
+                    box_result=box_results,
+                    context=context,
+                )
+                results[index] = result
+                logger.debug(f"{run_desc} finished successfully.")
+            except Exception as e:
+                logger.error(f"{run_desc} failed: {e}", exc_info=not return_errors)
+                if return_errors:
+                    results[index] = e
+                else:
+                    raise  # Propagate to calling gather
+            finally:
+                if progress_context:
+                    progress.update(progress_task_id, advance=1)
+
+        # ThreadPool worker for real parallelism (suitable for blocking I/O)
+        def _thread_worker(index: int, item_inputs: dict[str, Any]):
+            """Synchronous helper executed inside a worker thread."""
+            full_input = {**(static_inputs or {}), **item_inputs}
+            run_desc = f"Batch item {index + 1}"
+            logger.debug(f"{run_desc} started (thread).")
+            try:
+                # Use the synchronous wrapper to avoid nested event-loop issues inside threads
+                result = self.flock.run(
+                    start_agent=start_agent,
+                    input=full_input,
+                    box_result=box_results,
+                )
+                logger.debug(f"{run_desc} finished successfully.")
+                return index, result, None
+            except Exception as e:
+                logger.error(f"{run_desc} failed: {e}")
+                return index, None, e
 
+        async def thread_worker(executor, index: int, item_inputs: dict[str, Any]):
+            """Coroutine wrapper that submits _thread_worker to the specified executor."""
+            loop = asyncio.get_running_loop()
+            idx, res, err = await loop.run_in_executor(
+                executor, _thread_worker, index, item_inputs
+            )
+            # Handle result / error on the asyncio side
+            if err:
+                if return_errors:
+                    results[idx] = err
+                else:
+                    raise err
+            else:
+                results[idx] = res
+            if progress_context:
+                progress.update(progress_task_id, advance=1)
+
+        tasks = []
         try:
             if effective_use_temporal:
                 # Temporal Batching (Simplified: sequential execution for this example)
@@ -238,25 +264,32 @@ class BatchProcessor:
                     "Running batch using Temporal (executing sequentially for now)..."
                 )
                 for i, item_data in enumerate(prepared_batch_inputs):
-                    await worker(i, item_data)  # Run sequentially for demo
+                    await async_worker(i, item_data)  # Run sequentially for demo
                 # TODO: Implement true parallel Temporal workflow execution if needed
 
             elif parallel:
+                # --- Real parallelism using ThreadPoolExecutor ---
                 logger.info(
-                    f"Running batch in parallel with max_workers={max_workers}..."
+                    f"Running batch in parallel (threads) with max_workers={max_workers}..."
                 )
-                for i, item_data in enumerate(prepared_batch_inputs):
-                    tasks.append(asyncio.create_task(worker(i, item_data)))
-                await asyncio.gather(
-                    *tasks
-                )  # gather handles exceptions based on return_errors logic in worker
+                loop = asyncio.get_running_loop()
+                with concurrent.futures.ThreadPoolExecutor(
+                    max_workers=max_workers, thread_name_prefix="flock-batch"
+                ) as executor:
+                    for i, item_data in enumerate(prepared_batch_inputs):
+                        tasks.append(
+                            asyncio.create_task(
+                                thread_worker(executor, i, item_data)
+                            )
+                        )
+
+                    # Wait for all tasks allowing exceptions to propagate as needed
+                    await asyncio.gather(*tasks)
 
             else:  # Sequential Local
                 logger.info("Running batch sequentially...")
                 for i, item_data in enumerate(prepared_batch_inputs):
-                    await worker(
-                        i, item_data
-                    )  # Already handles errors internally based on return_errors
+                    await async_worker(i, item_data)  # Already handles errors internally based on return_errors
 
             logger.info("Batch execution finished.")
 

flock/core/flock.py

@@ -6,7 +6,7 @@ from __future__ import annotations  # Ensure forward references work
 import asyncio
 import os
 import uuid
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
@@ -32,6 +32,7 @@ from pydantic import BaseModel, Field
 
 # Flock core components & utilities
 from flock.config import DEFAULT_MODEL, TELEMETRY
+from flock.core.api.custom_endpoint import FlockEndpoint
 from flock.core.context.context import FlockContext
 from flock.core.context.context_manager import initialize_context
 from flock.core.execution.temporal_executor import run_temporal_workflow
@@ -116,7 +117,7 @@ class Flock(BaseModel, Serializable):
     # Internal agent storage - not part of the Pydantic model for direct serialization
     _agents: dict[str, FlockAgent]
     _start_agent_name: str | None = None  # For potential pre-configuration
-    _start_input: dict = {}  # For potential pre-configuration
+    _start_input: dict = {}  # Instance attribute overwritten in __init__; kept for typing clarity
 
     # Pydantic v2 model config
     model_config = {
@@ -276,7 +277,7 @@ class Flock(BaseModel, Serializable):
     def run(
         self,
         start_agent: FlockAgent | str | None = None,
-        input: dict = {},
+        input: dict | None = None,
         context: FlockContext | None = None,
         run_id: str = "",
         box_result: bool = True,
@@ -685,6 +686,7 @@ class Flock(BaseModel, Serializable):
         server_name: str = "Flock API",
         create_ui: bool = False,
         ui_theme: str | None = None,
+        custom_endpoints: Sequence[FlockEndpoint] | dict[tuple[str, list[str] | None], Callable[..., Any]] | None = None,
     ) -> None:
         """Starts a REST API server for this Flock instance.
         If create_ui is True, integrates the web UI, potentially with a specific theme.
@@ -734,6 +736,7 @@ class Flock(BaseModel, Serializable):
                 port=port,
                 server_name=server_name,
                 create_ui=False,  # Explicitly false for API only runner
+                custom_endpoints=custom_endpoints,
             )
 
     # --- CLI Starter ---

flock/core/flock_registry.py

@@ -169,17 +169,31 @@ class FlockRegistry:
             return None
 
     # --- Agent Registration ---
-    def register_agent(self, agent: FlockAgent) -> None:
-        """Registers a FlockAgent instance by its name."""
+    def register_agent(self, agent: FlockAgent, *, force: bool = False) -> None:
+        """Registers a FlockAgent instance by its name.
+
+        Args:
+            agent: The agent instance to register.
+            force: If True, allow overwriting an existing **different** agent registered under the same name.
+                   If False and a conflicting registration exists, a ValueError is raised.
+        """
         if not hasattr(agent, "name") or not agent.name:
             logger.error(
                 "Attempted to register an agent without a valid 'name' attribute."
             )
             return
-        if agent.name in self._agents and self._agents[agent.name] != agent:
+
+        if agent.name in self._agents and self._agents[agent.name] is not agent:
+            # Same agent already registered → silently ignore; different instance → error/force.
+            if not force:
+                raise ValueError(
+                    f"Agent '{agent.name}' already registered with a different instance. "
+                    "Pass force=True to overwrite the existing registration."
+                )
             logger.warning(
-                f"Agent '{agent.name}' already registered. Overwriting."
+                f"Overwriting existing agent '{agent.name}' registration due to force=True."
             )
+
         self._agents[agent.name] = agent
         logger.debug(f"Registered agent: {agent.name}")
 

flock/core/logging/telemetry.py

@@ -42,6 +42,9 @@ class TelemetryConfig:
         enable_jaeger: bool = True,
         enable_file: bool = True,
         enable_sql: bool = True,
+        enable_otlp: bool = True,
+        otlp_protocol: str = "grpc",
+        otlp_endpoint: str = "http://localhost:4317",
         batch_processor_options: dict | None = None,
     ):
         """:param service_name: Name of your service.
@@ -61,6 +64,9 @@ class TelemetryConfig:
         self.enable_jaeger = enable_jaeger
         self.enable_file = enable_file
         self.enable_sql = enable_sql
+        self.enable_otlp = enable_otlp
+        self.otlp_protocol = otlp_protocol
+        self.otlp_endpoint = otlp_endpoint
         self.global_tracer = None
 
     def setup_tracing(self):
@@ -97,6 +103,32 @@ class TelemetryConfig:
 
             span_processors.append(SimpleSpanProcessor(jaeger_exporter))
 
+
+        if self.enable_otlp:
+            if self.otlp_protocol == "grpc":
+                from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import (
+                    OTLPSpanExporter,
+                )
+
+                otlp_exporter = OTLPSpanExporter(
+                    endpoint=self.otlp_endpoint,
+                    insecure=True,
+                )
+            elif self.otlp_protocol == "http":
+                from opentelemetry.exporter.otlp.proto.http.trace_exporter import (
+                    OTLPSpanExporter,
+                )
+
+                otlp_exporter = OTLPSpanExporter(
+                    collector_endpoint=self.otlp_endpoint,
+                )
+            else:
+                raise ValueError(
+                    "Invalid OTEL_EXPORTER_OTLP_PROTOCOL specified. Use 'grpc' or 'http'."
+                )
+
+            span_processors.append(SimpleSpanProcessor(otlp_exporter))
+
         # If a file path is provided, add the custom file exporter.
         if self.file_export_name and self.enable_file:
             file_exporter = FileSpanExporter(

{flock_core-0.4.0b38.dist-info → flock_core-0.4.0b40.dist-info}/METADATA

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

{flock_core-0.4.0b38.dist-info → flock_core-0.4.0b40.dist-info}/RECORD

@@ -1,5 +1,5 @@
 flock/__init__.py,sha256=1tMdEwpFvJXVso96jyGvGPXhD9P7EbZfkSV-WX1fXuE,5918
-flock/config.py,sha256=Nrip1Nn03KGVmRq2NYkuI-hJtnIVI1lHkurIrsPt7YI,1588
+flock/config.py,sha256=9aUYglHavosdTS212WXW9qc_snZVimvxaXZ3Z5NDGWM,1923
 flock/cli/config.py,sha256=5DvFLObOx3ObisHnc9JfnUBnK83y0CBsUQzXfxPZve0,138
 flock/cli/constants.py,sha256=ZyXtTW91P1hUMkbMwmOwp_JEL5e9-YkcuM3vHM5glP4,978
 flock/cli/create_agent.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
@@ -19,19 +19,20 @@ 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=HLJyWDdpUfDfpp-hHeyhrJty0FiOHBa8CBM2YrSMFyM,30139
+flock/core/flock.py,sha256=WzLA7-xoAUq7Yn_ioieQIsk6CG_VvvDPeq_S6FWNgOY,30424
 flock/core/flock_agent.py,sha256=JTqaGD_OnZSd3bVU989WMsK1rAT6UGn-JYrPxFV15EE,39576
 flock/core/flock_evaluator.py,sha256=dOXZeDOGZcAmJ9ahqq_2bdGUU1VOXY4skmwTVpAjiVw,1685
 flock/core/flock_factory.py,sha256=_4zsjkEmJnCR7IvJ3SUHnDbX6c7Tt3E4P5ohxwKvE6w,3173
 flock/core/flock_module.py,sha256=UCK6TFe4viXs596zeng0GD3gln4ZNGu_gCWkXIIMREg,3090
-flock/core/flock_registry.py,sha256=Qcu9juUFNyDAOEsqVxauwVlWdfgKZrSzc8yT8JMiK-c,24246
+flock/core/flock_registry.py,sha256=aC-RK0js676DQkjXmNuYHuD5t6GmFhpQoCKaO3i7xFg,24920
 flock/core/flock_router.py,sha256=1OAXDsdaIIFApEfo6SRfFEDoTuGt3Si7n2MXiySEfis,2644
 flock/core/api/__init__.py,sha256=OKlhzDWZJfA6ddBwxQUmATY0TSzESsH032u00iVGvdA,228
+flock/core/api/custom_endpoint.py,sha256=nCm8lhvq1OOVlHB5f1DD1Pgm5U-PgggPlYjlMRK4nPc,1090
 flock/core/api/endpoints.py,sha256=qQnJmtcYGkjdKtLllVpyJVjc-iZrvu5EEeVIryyt4tc,12987
-flock/core/api/main.py,sha256=Z8XSHV9iJsVr5k_77GqOZrdc9Lr5CJZ_N3SfaPNlixE,23663
+flock/core/api/main.py,sha256=f7uZkl8wIOLSoaIztdRG40LqmmRQSdIe-WxXsZx4Q-U,28681
 flock/core/api/models.py,sha256=seqKuzhbN37nCNO7KrcJjI2mWuwiOKCLFcJcTPvTtag,3422
 flock/core/api/run_store.py,sha256=bFodJvVyWogzoezVy0cOoWWU3MdEBXf_6_5sBqCRWps,9227
-flock/core/api/runner.py,sha256=PjKQyMNawHm_N-X2uTUWBKAKBe7AEzNmRIGwQI6tUWw,1156
+flock/core/api/runner.py,sha256=3izg6cVk1RoR1hDIDwMAO1gi3lnLcp8DPv7AnJBYx6A,1443
 flock/core/api/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 flock/core/api/ui/routes.py,sha256=nS-wWO94mshE5ozWfOQZ-HOvtes_1qxDVcqpMZtU5JQ,8885
 flock/core/api/ui/utils.py,sha256=V7PqYHNK519hFJ8jvvwf7bGpbBXCRz_HQG3BDCCqlNA,4802
@@ -39,14 +40,14 @@ flock/core/context/context.py,sha256=GFqMwYXLheqECGvWcxar7sQ2-GuY3RVynZ7kjwd65R0
 flock/core/context/context_manager.py,sha256=FANSWa6DEhdhtZ7t_9Gza0v80UdpoDOhHbfVOccmjkA,1181
 flock/core/context/context_vars.py,sha256=ASPA29hpENWub4mgRoG62FtTVakCHQZfn6IhJQKe3C8,347
 flock/core/evaluation/utils.py,sha256=ZJkIMC9YT-HA2SPCZ4_bQ98isW1i6nbltVEYbjze-b0,12827
-flock/core/execution/batch_executor.py,sha256=nvsFOVaH4c4uPw_gwZ5jCIULpK59EL1kmcoPTja5kko,13745
+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/temporal_executor.py,sha256=dHcb0xuzPFWU_wbwTgI7glLNyyppei93Txs2sapjhaw,6283
 flock/core/interpreter/python_interpreter.py,sha256=RaUMZuufsKBNQ4FAeSaOgUuxzs8VYu5TgUUs-xwaxxM,26376
 flock/core/logging/__init__.py,sha256=Q8hp9-1ilPIUIV0jLgJ3_cP7COrea32cVwL7dicPnlM,82
 flock/core/logging/logging.py,sha256=JcgABQ8QJU1hhzhfF93eqnE0jhyXGZ2oObZst68sKR8,15409
-flock/core/logging/telemetry.py,sha256=3E9Tyj6AUR6A5RlIufcdCdWm5BAA7tbOsCa7lHoUQaU,5404
+flock/core/logging/telemetry.py,sha256=3pApCiKAHbznuCBpJhlDxOrDJWK8cLs3ENk8CpA6WKc,6571
 flock/core/logging/trace_and_logged.py,sha256=5vNrK1kxuPMoPJ0-QjQg-EDJL1oiEzvU6UNi6X8FiMs,2117
 flock/core/logging/formatters/enum_builder.py,sha256=LgEYXUv84wK5vwHflZ5h8HBGgvLH3sByvUQe8tZiyY0,981
 flock/core/logging/formatters/theme_builder.py,sha256=Wnaal3HuUDA4HFg9tdql1BxYwK83ACOZBBQy-DXnxcA,17342
@@ -494,8 +495,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.0b38.dist-info/METADATA,sha256=dTj3MvtPziPOThF3PqR54KUQFCpgAHF3cDKyBdNiwvQ,17125
-flock_core-0.4.0b38.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.4.0b38.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.4.0b38.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.4.0b38.dist-info/RECORD,,
+flock_core-0.4.0b40.dist-info/METADATA,sha256=W-nPONRJfGIBfsyt2hEPqtLqu6mxQto7fP1IYuw1oH8,17125
+flock_core-0.4.0b40.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.4.0b40.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.4.0b40.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.4.0b40.dist-info/RECORD,,