flock-core 0.4.0b42__tar.gz → 0.4.0b44__tar.gz

{flock_core-0.4.0b42 → flock_core-0.4.0b44}/PKG-INFO

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

{flock_core-0.4.0b42 → flock_core-0.4.0b44}/pyproject.toml

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

{flock_core-0.4.0b42 → flock_core-0.4.0b44}/src/flock/core/api/__init__.py

@@ -1,11 +1,10 @@
 # src/flock/core/api/__init__.py
 """Flock API Server components."""
 
-from .main import FlockAPI
+
 from .models import FlockAPIRequest, FlockAPIResponse
 
 __all__ = [
-    "FlockAPI",
     "FlockAPIRequest",
     "FlockAPIResponse",
 ]

flock_core-0.4.0b44/src/flock/core/api/endpoints.py

@@ -0,0 +1,254 @@
+# src/flock/core/api/endpoints.py
+"""FastAPI endpoints for the Flock API, using FastAPI's dependency injection."""
+
+import uuid
+from typing import TYPE_CHECKING
+
+from fastapi import (
+    APIRouter,
+    BackgroundTasks,
+    Depends,  # Crucial import for dependency injection
+    HTTPException,
+)
+
+from flock.core.logging.logging import get_logger
+
+# Import the dependency provider functions
+# This assumes you'll create 'src/flock/webapp/app/dependencies.py' (or similar)
+# with get_flock_instance and get_run_store functions.
+# For now, to make this file runnable in isolation for generation,
+# we might need temporary stubs or to adjust the import path later.
+# Let's assume a common location for dependencies.
+from flock.webapp.app.dependencies import get_flock_instance, get_run_store
+
+from .models import (
+    FlockAPIRequest,
+    FlockAPIResponse,
+    FlockBatchRequest,
+    FlockBatchResponse,
+)
+
+if TYPE_CHECKING:
+    from flock.core.flock import Flock
+
+    from .run_store import RunStore
+    # We also need the _run_flock, _run_batch, _type_convert_inputs methods.
+    # These will be part of the Flock instance itself or helper functions
+    # that take Flock/RunStore as arguments. For now, let's assume they
+    # are methods on the Flock instance or can be called statically with it.
+
+logger = get_logger("api.endpoints")
+
+# The create_api_router function no longer needs to be passed the FlockAPI instance
+# as dependencies will be injected directly into the route handlers.
+def create_api_router() -> APIRouter:
+    """Creates the APIRouter for core Flock API endpoints."""
+    router = APIRouter()
+
+    # --- API Endpoints ---
+    @router.post("/run/flock", response_model=FlockAPIResponse, tags=["Flock API Core"])
+    async def run_flock_workflow(
+        request_model: FlockAPIRequest, # Renamed from 'request' to avoid conflict with FastAPI's Request
+        background_tasks: BackgroundTasks,
+        flock_instance: "Flock" = Depends(get_flock_instance), # Injected
+        run_store: "RunStore" = Depends(get_run_store)          # Injected
+    ):
+        """Run a flock workflow starting with the specified agent."""
+        run_id = None
+        try:
+            run_id = str(uuid.uuid4())
+            run_store.create_run(run_id)
+            response_data = run_store.get_run(run_id)
+
+            if not response_data:
+                logger.error(f"Failed to create run record for run_id: {run_id}")
+                raise HTTPException(status_code=500, detail="Failed to initialize run.")
+
+            processed_inputs = request_model.inputs if request_model.inputs else {}
+            logger.info(
+                f"API request: run flock '{request_model.agent_name}' (run_id: {run_id})",
+                inputs=processed_inputs,
+            )
+
+            # The _run_flock logic now needs to be called. It could be a method on
+            # flock_instance, or a static/helper function that takes flock_instance.
+            # Let's assume it's a method on flock_instance for now.
+            # To avoid direct calls to private-like methods from router,
+            # Flock class would expose a public method that handles this internal logic.
+            # For this refactoring step, let's assume a helper `_execute_flock_run` exists
+            # that we can call.
+
+            async def _execute_flock_run_task(run_id_task, agent_name_task, inputs_task):
+                # This is a simplified version of what was in FlockAPI._run_flock
+                try:
+                    if agent_name_task not in flock_instance.agents:
+                        raise ValueError(f"Starting agent '{agent_name_task}' not found")
+                    # Type conversion would ideally be part of the Flock's run logic
+                    # or a utility. For now, assume it's handled or simple.
+                    # typed_inputs = flock_instance._type_convert_inputs(agent_name_task, inputs_task) # Example if kept on Flock
+                    typed_inputs = inputs_task # Simplified for now
+
+                    result = await flock_instance.run_async(
+                        start_agent=agent_name_task, input=typed_inputs
+                    )
+                    run_store.update_run_result(run_id_task, result)
+                except Exception as e_task:
+                    logger.error(f"Error in background flock run {run_id_task}: {e_task!s}", exc_info=True)
+                    run_store.update_run_status(run_id_task, "failed", str(e_task))
+
+
+            if request_model.async_run:
+                logger.debug(
+                    f"Running flock '{request_model.agent_name}' asynchronously (run_id: {run_id})"
+                )
+                background_tasks.add_task(
+                    _execute_flock_run_task,
+                    run_id,
+                    request_model.agent_name,
+                    processed_inputs,
+                )
+                run_store.update_run_status(run_id, "running")
+                response_data.status = "running"
+            else:
+                logger.debug(
+                    f"Running flock '{request_model.agent_name}' synchronously (run_id: {run_id})"
+                )
+                await _execute_flock_run_task(
+                     run_id, request_model.agent_name, processed_inputs
+                )
+                response_data = run_store.get_run(run_id)
+
+            if not response_data:
+                 logger.error(f"Run data lost for run_id: {run_id} after execution.")
+                 raise HTTPException(status_code=500, detail="Run data lost after execution.")
+
+            return response_data
+        except ValueError as ve:
+            logger.error(f"Value error starting run for agent '{request_model.agent_name}': {ve}", exc_info=True)
+            if run_id: run_store.update_run_status(run_id, "failed", str(ve))
+            raise HTTPException(status_code=400, detail=str(ve))
+        except Exception as e:
+            error_msg = f"Internal server error during flock run: {type(e).__name__}"
+            logger.error(f"Error starting flock run: {e!s}", exc_info=True)
+            if run_id: run_store.update_run_status(run_id, "failed", error_msg)
+            raise HTTPException(status_code=500, detail=error_msg)
+
+    @router.post("/run/batch", response_model=FlockBatchResponse, tags=["Flock API Core"])
+    async def run_batch_workflow(
+        request_model: FlockBatchRequest, # Renamed from 'request'
+        background_tasks: BackgroundTasks,
+        flock_instance: "Flock" = Depends(get_flock_instance),
+        run_store: "RunStore" = Depends(get_run_store)
+    ):
+        """Run a batch of inputs through the flock workflow."""
+        batch_id = None
+        try:
+            if request_model.agent_name not in flock_instance.agents:
+                raise ValueError(f"Agent '{request_model.agent_name}' not found in current Flock.")
+
+            if isinstance(request_model.batch_inputs, list) and not request_model.batch_inputs:
+                raise ValueError("Batch inputs list cannot be empty if provided as a list.")
+
+            batch_id = str(uuid.uuid4())
+            run_store.create_batch(batch_id)
+            response_data = run_store.get_batch(batch_id)
+
+            if not response_data:
+                logger.error(f"Failed to create batch record for batch_id: {batch_id}")
+                raise HTTPException(status_code=500, detail="Failed to initialize batch run.")
+
+            batch_size = (
+                len(request_model.batch_inputs)
+                if isinstance(request_model.batch_inputs, list)
+                else "CSV/DataFrame"
+            )
+            logger.info(
+                f"API request: run batch with '{request_model.agent_name}' (batch_id: {batch_id})",
+                batch_size=batch_size,
+            )
+
+            async def _execute_flock_batch_task(batch_id_task, batch_request_task: FlockBatchRequest):
+                # This is a simplified version of what was in FlockAPI._run_batch
+                try:
+                    # Directly use the flock_instance's run_batch_async method
+                    results = await flock_instance.run_batch_async(
+                        start_agent=batch_request_task.agent_name,
+                        batch_inputs=batch_request_task.batch_inputs,
+                        input_mapping=batch_request_task.input_mapping,
+                        static_inputs=batch_request_task.static_inputs,
+                        parallel=batch_request_task.parallel,
+                        max_workers=batch_request_task.max_workers,
+                        use_temporal=batch_request_task.use_temporal,
+                        box_results=batch_request_task.box_results,
+                        return_errors=batch_request_task.return_errors,
+                        silent_mode=True, # API batch runs should be internally silent
+                        write_to_csv=None # API handles CSV writing based on request if needed, not here
+                    )
+                    run_store.update_batch_result(batch_id_task, results)
+                    logger.info(f"Batch run completed (batch_id: {batch_id_task})", num_results=len(results))
+                except Exception as e_task:
+                    logger.error(f"Error in background flock batch {batch_id_task}: {e_task!s}", exc_info=True)
+                    run_store.update_batch_status(batch_id_task, "failed", str(e_task))
+
+            logger.debug(
+                f"Running batch with '{request_model.agent_name}' asynchronously (batch_id: {batch_id})"
+            )
+            background_tasks.add_task(
+                _execute_flock_batch_task,
+                batch_id,
+                request_model, # Pass the Pydantic request model
+            )
+            run_store.update_batch_status(batch_id, "running")
+            response_data.status = "running"
+
+            return response_data
+        except ValueError as ve:
+            error_msg = f"Value error starting batch for agent '{request_model.agent_name}': {ve}"
+            logger.error(error_msg, exc_info=True)
+            if batch_id: run_store.update_batch_status(batch_id, "failed", str(ve))
+            raise HTTPException(status_code=400, detail=str(ve))
+        except Exception as e:
+            error_msg = f"Internal server error during batch run: {type(e).__name__}: {e!s}"
+            logger.error(error_msg, exc_info=True)
+            if batch_id: run_store.update_batch_status(batch_id, "failed", error_msg)
+            raise HTTPException(status_code=500, detail=error_msg)
+
+    @router.get("/run/{run_id}", response_model=FlockAPIResponse, tags=["Flock API Core"])
+    async def get_run_status(
+        run_id: str,
+        run_store: "RunStore" = Depends(get_run_store)
+    ):
+        """Get the status of a specific run."""
+        logger.debug(f"API request: get status for run_id: {run_id}")
+        run_data = run_store.get_run(run_id)
+        if not run_data:
+            logger.warning(f"Run ID not found: {run_id}")
+            raise HTTPException(status_code=404, detail="Run not found")
+        return run_data
+
+    @router.get("/batch/{batch_id}", response_model=FlockBatchResponse, tags=["Flock API Core"])
+    async def get_batch_status(
+        batch_id: str,
+        run_store: "RunStore" = Depends(get_run_store)
+    ):
+        """Get the status and results of a specific batch run."""
+        logger.debug(f"API request: get status for batch_id: {batch_id}")
+        batch_data = run_store.get_batch(batch_id)
+        if not batch_data:
+            logger.warning(f"Batch ID not found: {batch_id}")
+            raise HTTPException(status_code=404, detail="Batch not found")
+        return batch_data
+
+    @router.get("/agents", tags=["Flock API Core"])
+    async def list_agents(
+        flock_instance: "Flock" = Depends(get_flock_instance)
+    ):
+        """List all available agents in the currently loaded Flock."""
+        logger.debug("API request: list agents")
+        agents_list = [
+            {"name": agent.name, "description": agent.description or agent.name}
+            for agent in flock_instance.agents.values()
+        ]
+        return {"agents": agents_list}
+
+    return router

flock_core-0.4.0b44/src/flock/core/api/main.py

@@ -0,0 +1,162 @@
+# src/flock/core/api/main.py
+"""This module defines the FlockAPI class, which is now primarily responsible for
+managing and adding user-defined custom API endpoints to a main FastAPI application.
+"""
+
+import inspect
+from collections.abc import Callable, Sequence
+from typing import TYPE_CHECKING, Any
+
+from fastapi import (  # Ensure Request is aliased
+    Body,
+    Depends,
+    FastAPI,
+    Request as FastAPIRequest,
+)
+
+from flock.core.logging.logging import get_logger
+
+from .custom_endpoint import FlockEndpoint
+
+if TYPE_CHECKING:
+    from flock.core.flock import Flock
+
+logger = get_logger("core.api.custom_setup")
+
+
+class FlockAPI:
+    """A helper class to manage the addition of user-defined custom API endpoints
+    to an existing FastAPI application, in the context of a Flock instance.
+    """
+
+    def __init__(
+        self,
+        flock_instance: "Flock",
+        custom_endpoints: Sequence[FlockEndpoint] | dict[tuple[str, list[str] | None], Callable[..., Any]] | None = None,
+    ):
+        self.flock = flock_instance
+        self.processed_custom_endpoints: list[FlockEndpoint] = []
+        if custom_endpoints:
+            if isinstance(custom_endpoints, dict):
+                logger.warning("Received custom_endpoints as dict, converting. Prefer Sequence[FlockEndpoint].")
+                for (path, methods), cb in custom_endpoints.items():
+                    self.processed_custom_endpoints.append(
+                        FlockEndpoint(path=path, methods=list(methods) if methods else ["GET"], callback=cb)
+                    )
+            elif isinstance(custom_endpoints, Sequence):
+                for ep_item in custom_endpoints: # Renamed loop variable
+                    if isinstance(ep_item, FlockEndpoint):
+                        self.processed_custom_endpoints.append(ep_item)
+                    else:
+                        logger.warning(f"Skipping non-FlockEndpoint item in custom_endpoints sequence: {type(ep_item)}")
+            else:
+                logger.warning(f"Unsupported type for custom_endpoints: {type(custom_endpoints)}")
+        logger.info(
+            f"FlockAPI helper initialized for Flock: '{self.flock.name}'. "
+            f"Prepared {len(self.processed_custom_endpoints)} custom endpoints."
+        )
+
+    def add_custom_routes_to_app(self, app: FastAPI):
+        if not self.processed_custom_endpoints:
+            logger.debug("No custom endpoints to add to the FastAPI app.")
+            return
+
+        logger.info(f"Adding {len(self.processed_custom_endpoints)} custom endpoints to the FastAPI app instance.")
+
+        for current_ep_def in self.processed_custom_endpoints: # Use current_ep_def to avoid closure issues
+
+            # This factory now takes current_ep_def to ensure it uses the correct endpoint's details
+            def _create_handler_factory(
+                # Capture the specific endpoint definition for this factory instance
+                specific_ep: FlockEndpoint
+            ):
+                # This inner function prepares the payload and calls the user's callback
+                async def _invoke_user_callback(
+                    request_param: FastAPIRequest, # Parameter for FastAPI's Request object
+                    body_param: Any,      # Will be populated by the _route_handler
+                    query_param: Any      # Will be populated by the _route_handler
+                ):
+                    payload_to_user: dict[str, Any] = {"flock": self.flock} # self here refers to FlockAPI instance
+
+                    if request_param: # Ensure request_param is not None
+                        payload_to_user.update(request_param.path_params)
+                        # query_param is already the parsed Pydantic model or None
+                        if specific_ep.query_model and query_param is not None:
+                            payload_to_user["query"] = query_param
+                        # Fallback for raw query if callback expects 'query' but no query_model was set
+                        elif 'query' in inspect.signature(specific_ep.callback).parameters and not specific_ep.query_model:
+                             if request_param.query_params:
+                                payload_to_user["query"] = dict(request_param.query_params)
+
+                        # body_param is already the parsed Pydantic model or None
+                        if specific_ep.request_model and body_param is not None:
+                            payload_to_user["body"] = body_param
+                        # Fallback for raw body if callback expects 'body' but no request_model was set
+                        elif 'body' in inspect.signature(specific_ep.callback).parameters and \
+                             not specific_ep.request_model and \
+                             request_param.method in {"POST", "PUT", "PATCH"}:
+                            try: payload_to_user["body"] = await request_param.json()
+                            except Exception: payload_to_user["body"] = await request_param.body()
+
+                        # If user callback explicitly asks for 'request'
+                        if 'request' in inspect.signature(specific_ep.callback).parameters:
+                            payload_to_user['request'] = request_param
+
+
+                    user_callback_sig = inspect.signature(specific_ep.callback)
+                    final_kwargs = {
+                        k: v for k, v in payload_to_user.items() if k in user_callback_sig.parameters
+                    }
+
+                    if inspect.iscoroutinefunction(specific_ep.callback):
+                        return await specific_ep.callback(**final_kwargs)
+                    return specific_ep.callback(**final_kwargs)
+
+                # --- Select the correct handler signature based on specific_ep's models ---
+                if specific_ep.request_model and specific_ep.query_model:
+                    async def _route_handler_body_query(
+                        request: FastAPIRequest, # Correct alias for FastAPI Request
+                        body: specific_ep.request_model = Body(...),  # type: ignore
+                        query: specific_ep.query_model = Depends(specific_ep.query_model)  # type: ignore
+                    ):
+                        return await _invoke_user_callback(request, body, query)
+                    return _route_handler_body_query
+                elif specific_ep.request_model and not specific_ep.query_model:
+                    async def _route_handler_body_only(
+                        request: FastAPIRequest, # Correct alias
+                        body: specific_ep.request_model = Body(...)  # type: ignore
+                    ):
+                        return await _invoke_user_callback(request, body, None)
+                    return _route_handler_body_only
+                elif not specific_ep.request_model and specific_ep.query_model:
+                    async def _route_handler_query_only(
+                        request: FastAPIRequest, # Correct alias
+                        query: specific_ep.query_model = Depends(specific_ep.query_model)  # type: ignore
+                    ):
+                        return await _invoke_user_callback(request, None, query)
+                    return _route_handler_query_only
+                else: # Neither request_model nor query_model
+                    async def _route_handler_request_only(
+                        request: FastAPIRequest # Correct alias
+                    ):
+                        return await _invoke_user_callback(request, None, None)
+                    return _route_handler_request_only
+
+            # Create the handler for the current_ep_def
+            selected_handler = _create_handler_factory(current_ep_def) # Pass current_ep_def
+            selected_handler.__name__ = f"handler_for_{current_ep_def.path.replace('/', '_').lstrip('_')}_{current_ep_def.methods[0]}"
+
+
+            app.add_api_route(
+                current_ep_def.path,
+                selected_handler,
+                methods=current_ep_def.methods or ["GET"],
+                name=current_ep_def.name or f"custom:{current_ep_def.path.replace('/', '_').lstrip('_')}",
+                include_in_schema=current_ep_def.include_in_schema,
+                response_model=current_ep_def.response_model,
+                summary=current_ep_def.summary,
+                description=current_ep_def.description,
+                dependencies=current_ep_def.dependencies,
+                tags=["Flock API Custom Endpoints"],
+            )
+            logger.debug(f"Added custom route to app: {current_ep_def.methods} {current_ep_def.path} (Handler: {selected_handler.__name__}, Summary: {current_ep_def.summary})")

flock_core-0.4.0b44/src/flock/core/api/service.py

@@ -0,0 +1,214 @@
+# flock/core/api/service.py
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from flock.core.api.endpoints import FlockBatchRequest
+    from flock.core.api.run_store import RunStore
+    from flock.core.flock import Flock
+
+
+from flock.core.logging.logging import get_logger
+
+logger = get_logger("flock.api")
+
+class FlockApiService:
+    def __init__(self, flock_instance: "Flock", run_store_instance: "RunStore"):
+        self.flock = flock_instance
+        self.run_store = run_store_instance
+    # You would move the _run_flock, _run_batch, _type_convert_inputs methods here
+    # from the old FlockAPI class.
+    async def _run_flock(
+        self, run_id: str, agent_name: str, inputs: dict[str, Any]
+    ):
+        """Executes a flock workflow run (internal helper)."""
+        try:
+            if agent_name not in self.flock.agents:
+                raise ValueError(f"Starting agent '{agent_name}' not found")
+
+            typed_inputs = self._type_convert_inputs(agent_name, inputs)
+
+            logger.debug(
+                f"Executing flock workflow starting with '{agent_name}' (run_id: {run_id})",
+                inputs=typed_inputs,
+            )
+            # Flock.run_async now handles context creation and execution
+            result = await self.flock.run_async(
+                start_agent=agent_name, input=typed_inputs
+            )
+            self.run_store.update_run_result(run_id, result)
+
+            final_agent_name = (
+                result.get("agent_name", "N/A") if isinstance(result, dict) else "N/A"
+            ) # Handle if result is not a dict (e.g. Box)
+            logger.info(
+                f"Flock workflow completed (run_id: {run_id})",
+                final_agent=final_agent_name,
+            )
+        except Exception as e:
+            logger.error(
+                f"Error in flock run {run_id} (started with '{agent_name}'): {e!s}",
+                exc_info=True,
+            )
+            self.run_store.update_run_status(run_id, "failed", str(e))
+            raise
+
+    async def _run_batch(self, batch_id: str, request: "FlockBatchRequest"):
+        """Executes a batch of runs (internal helper)."""
+        try:
+            if request.agent_name not in self.flock.agents:
+                raise ValueError(f"Agent '{request.agent_name}' not found")
+
+            logger.debug(
+                f"Executing batch run starting with '{request.agent_name}' (batch_id: {batch_id})",
+                batch_size=len(request.batch_inputs)
+                if isinstance(request.batch_inputs, list)
+                else "CSV/DataFrame",
+            )
+
+            # --- Re-integrating the threaded batch execution from Flock.run_batch_async ---
+            import asyncio
+            import threading
+            from concurrent.futures import ThreadPoolExecutor
+
+            def run_batch_sync_in_thread():
+                loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(loop)
+                try:
+                    batch_size = (
+                        len(request.batch_inputs)
+                        if isinstance(request.batch_inputs, list)
+                        else 0 # Or attempt to get from DataFrame/CSV load
+                    )
+                    if batch_size > 0:
+                        self.run_store.set_batch_total_items(batch_id, batch_size)
+
+                    class ProgressTracker:
+                        def __init__(self, store, b_id, total_size):
+                            self.store, self.batch_id, self.total_size = store, b_id, total_size
+                            self.current_count, self.partial_results, self._lock = 0, [], threading.Lock()
+                        def increment(self, res=None):
+                            with self._lock:
+                                self.current_count += 1
+                                if res is not None: self.partial_results.append(res)
+                                try: self.store.update_batch_progress(self.batch_id, self.current_count, self.partial_results)
+                                except Exception as e_prog: logger.error(f"Error updating progress: {e_prog}")
+                                return self.current_count
+
+                    progress_tracker = ProgressTracker(self.run_store, batch_id, batch_size)
+
+                    async def progress_aware_worker(index, item_inputs):
+                        try:
+                            # Call Flock's run_async for a single item
+                            item_result = await self.flock.run_async(
+                                start_agent=request.agent_name,
+                                input=item_inputs,
+                                box_result=request.box_results,
+                            )
+                            progress_tracker.increment(item_result)
+                            return item_result
+                        except Exception as item_err:
+                            logger.error(f"Error processing batch item {index}: {item_err}")
+                            progress_tracker.increment(item_err if request.return_errors else None)
+                            if request.return_errors: return item_err
+                            return None
+
+                    batch_inputs_list = request.batch_inputs
+                    actual_results_list = []
+
+                    if isinstance(batch_inputs_list, list):
+                        tasks = []
+                        for i, item_inputs in enumerate(batch_inputs_list):
+                            full_inputs = {**(request.static_inputs or {}), **item_inputs}
+                            tasks.append(progress_aware_worker(i, full_inputs))
+
+                        if request.parallel and request.max_workers > 1:
+                            semaphore = asyncio.Semaphore(request.max_workers)
+                            async def bounded_worker(idx, inputs_item):
+                                async with semaphore: return await progress_aware_worker(idx, inputs_item)
+                            bounded_tasks = [bounded_worker(i, {**(request.static_inputs or {}), **item}) for i, item in enumerate(batch_inputs_list)]
+                            actual_results_list = loop.run_until_complete(asyncio.gather(*bounded_tasks, return_exceptions=request.return_errors))
+                        else:
+                            for i, item_inputs in enumerate(batch_inputs_list):
+                                full_inputs = {**(request.static_inputs or {}), **item_inputs}
+                                actual_results_list.append(loop.run_until_complete(progress_aware_worker(i, full_inputs)))
+                    else: # DataFrame or CSV path - let Flock's batch processor handle this directly
+                        # This path relies on self.flock.run_batch_async being able to run within this new event loop.
+                        # It might be simpler to always convert DataFrame/CSV to list of dicts before this point.
+                        actual_results_list = loop.run_until_complete(
+                            self.flock.run_batch_async(
+                                start_agent=request.agent_name,
+                                batch_inputs=request.batch_inputs, # DataFrame or path
+                                input_mapping=request.input_mapping,
+                                static_inputs=request.static_inputs,
+                                parallel=request.parallel, # Will be re-evaluated by internal BatchProcessor
+                                max_workers=request.max_workers,
+                                use_temporal=request.use_temporal, # Will be re-evaluated
+                                box_results=request.box_results,
+                                return_errors=request.return_errors,
+                                silent_mode=True, # Internal batch runs silently for API
+                                write_to_csv=None # API handles CSV output separately if needed
+                            )
+                        )
+                        # Progress for DataFrame/CSV would need integration into BatchProcessor or this loop
+                        if actual_results_list:
+                             self.run_store.set_batch_total_items(batch_id, len(actual_results_list))
+                             self.run_store.update_batch_progress(batch_id, len(actual_results_list), actual_results_list)
+
+
+                    self.run_store.update_batch_result(batch_id, actual_results_list)
+                    logger.info(f"Batch run completed (batch_id: {batch_id})", num_results=len(actual_results_list))
+                    return actual_results_list
+                except Exception as thread_err:
+                    logger.error(f"Error in batch run thread {batch_id}: {thread_err!s}", exc_info=True)
+                    self.run_store.update_batch_status(batch_id, "failed", str(thread_err))
+                    return None
+                finally:
+                    loop.close()
+            # --- End of re-integrated threaded batch execution ---
+
+            # Submit the synchronous function to a thread pool from the main event loop
+            main_loop = asyncio.get_running_loop()
+            with ThreadPoolExecutor(thread_name_prefix="flock-api-batch") as pool:
+                await main_loop.run_in_executor(pool, run_batch_sync_in_thread)
+
+        except Exception as e:
+            logger.error(
+                f"Error setting up batch run {batch_id} (started with '{request.agent_name}'): {e!s}",
+                exc_info=True,
+            )
+            self.run_store.update_batch_status(batch_id, "failed", str(e))
+            raise
+
+
+
+
+
+    def _type_convert_inputs(
+        self, agent_name: str, inputs: dict[str, Any]
+    ) -> dict[str, Any]:
+        """Converts input values (esp. from forms) to expected Python types."""
+        typed_inputs = {}
+        agent_def = self.flock.agents.get(agent_name)
+        if not agent_def or not agent_def.input or not isinstance(agent_def.input, str):
+            return inputs # Return original if no spec or spec is not a string
+
+        parsed_fields = self._parse_input_spec(agent_def.input) # Relies on the old UI helper
+        field_types = {f["name"]: f["type"] for f in parsed_fields}
+
+        for k, v in inputs.items():
+            target_type_str = field_types.get(k)
+            if target_type_str:
+                if target_type_str.startswith("bool"):
+                    typed_inputs[k] = str(v).lower() in ["true", "on", "1", "yes"] if isinstance(v, str) else bool(v)
+                elif target_type_str.startswith("int"):
+                    try: typed_inputs[k] = int(v)
+                    except (ValueError, TypeError): logger.warning(f"Could not convert '{k}' value '{v}' to int for agent '{agent_name}'"); typed_inputs[k] = v
+                elif target_type_str.startswith("float"):
+                    try: typed_inputs[k] = float(v)
+                    except (ValueError, TypeError): logger.warning(f"Could not convert '{k}' value '{v}' to float for agent '{agent_name}'"); typed_inputs[k] = v
+                # TODO: Add list/dict parsing (e.g., json.loads) if type_str indicates these,
+                # especially if inputs come from HTML forms as strings.
+                else: typed_inputs[k] = v
+            else:
+                typed_inputs[k] = v
+        return typed_inputs