flock-core 0.3.3__py3-none-any.whl → 0.3.4__py3-none-any.whl

flock/core/__init__.py

@@ -2,12 +2,14 @@
 
 from flock.core.flock import Flock
 from flock.core.flock_agent import FlockAgent
+from flock.core.flock_api import FlockAPI
 from flock.core.flock_evaluator import FlockEvaluator, FlockEvaluatorConfig
 from flock.core.flock_factory import FlockFactory
 from flock.core.flock_module import FlockModule, FlockModuleConfig
 
 __all__ = [
     "Flock",
+    "FlockAPI",
     "FlockAgent",
     "FlockEvaluator",
     "FlockEvaluatorConfig",

flock/core/flock.py

@@ -379,6 +379,8 @@ class Flock:
             Exception: For any other errors encountered during execution.
         """
         with tracer.start_as_current_span("run_async") as span:
+            if isinstance(start_agent, str):
+                start_agent = self.registry.get_agent(start_agent)
             span.set_attribute(
                 "start_agent",
                 start_agent.name

flock/core/flock_api.py

@@ -0,0 +1,215 @@
+"""REST API server for Flock."""
+
+import uuid
+from datetime import datetime
+from typing import Any
+
+import uvicorn
+from fastapi import BackgroundTasks, FastAPI, HTTPException
+from pydantic import BaseModel, Field
+
+from flock.core.flock import Flock
+from flock.core.logging.logging import get_logger
+
+logger = get_logger("api")
+
+
+class FlockAPIRequest(BaseModel):
+    """Request model for running an agent."""
+
+    agent_name: str = Field(..., description="Name of the agent to run")
+    inputs: dict[str, Any] = Field(
+        default_factory=dict, description="Input data for the agent"
+    )
+    async_run: bool = Field(
+        default=False, description="Whether to run asynchronously"
+    )
+
+
+class FlockAPIResponse(BaseModel):
+    """Response model for run requests."""
+
+    run_id: str = Field(..., description="Unique ID for this run")
+    status: str = Field(..., description="Status of the run")
+    result: dict[str, Any] | None = Field(
+        None, description="Run result if completed"
+    )
+    started_at: datetime = Field(..., description="When the run started")
+    completed_at: datetime | None = Field(
+        None, description="When the run completed"
+    )
+    error: str | None = Field(None, description="Error message if failed")
+
+
+class FlockAPI:
+    """REST API server for Flock.
+
+    Provides HTTP endpoints for:
+    - Running agents
+    - Checking run status
+    - Getting run results
+    """
+
+    def __init__(self, flock: Flock):
+        self.flock = flock
+        self.app = FastAPI(title="Flock API")
+        self.runs: dict[str, FlockAPIResponse] = {}
+
+        # Register routes
+        self._setup_routes()
+
+    def _setup_routes(self):
+        """Set up API routes."""
+
+        @self.app.post("/run/flock", response_model=FlockAPIResponse)
+        async def run_flock(
+            request: FlockAPIRequest, background_tasks: BackgroundTasks
+        ):
+            """Run an agent with the provided inputs."""
+            try:
+                # Generate run ID
+                run_id = str(uuid.uuid4())
+
+                # Create initial response
+                response = FlockAPIResponse(
+                    run_id=run_id, status="starting", started_at=datetime.now()
+                )
+                self.runs[run_id] = response
+
+                if request.async_run:
+                    # Start run in background
+                    background_tasks.add_task(
+                        self._run_flock,
+                        run_id,
+                        request.agent_name,
+                        request.inputs,
+                    )
+                    response.status = "running"
+                else:
+                    # Run synchronously
+                    await self._run_flock(
+                        run_id, request.agent_name, request.inputs
+                    )
+
+                return self.runs[run_id]
+
+            except Exception as e:
+                logger.error(f"Error starting run: {e!s}")
+                raise HTTPException(status_code=500, detail=str(e))
+
+        @self.app.post("/run/agent", response_model=FlockAPIResponse)
+        async def run_agent(
+            request: FlockAPIRequest, background_tasks: BackgroundTasks
+        ):
+            """Run an agent with the provided inputs."""
+            try:
+                # Generate run ID
+                run_id = str(uuid.uuid4())
+
+                # Create initial response
+                response = FlockAPIResponse(
+                    run_id=run_id, status="starting", started_at=datetime.now()
+                )
+                self.runs[run_id] = response
+
+                if request.async_run:
+                    # Start run in background
+                    background_tasks.add_task(
+                        self._run_agent,
+                        run_id,
+                        request.agent_name,
+                        request.inputs,
+                    )
+                    response.status = "running"
+                else:
+                    # Run synchronously
+                    await self._run_agent(
+                        run_id, request.agent_name, request.inputs
+                    )
+
+                return self.runs[run_id]
+
+            except Exception as e:
+                logger.error(f"Error starting run: {e!s}")
+                raise HTTPException(status_code=500, detail=str(e))
+
+        @self.app.get("/run/{run_id}", response_model=FlockAPIResponse)
+        async def get_run_status(run_id: str):
+            """Get the status of a run."""
+            if run_id not in self.runs:
+                raise HTTPException(status_code=404, detail="Run not found")
+            return self.runs[run_id]
+
+        @self.app.get("/agents")
+        async def list_agents():
+            """List all available agents."""
+            return {
+                "agents": [
+                    {
+                        "name": agent.name,
+                        "description": agent.description,
+                        "input_schema": agent.input,
+                        "output_schema": agent.output,
+                        "hand_off": agent.hand_off,
+                    }
+                    for agent in self.flock.agents.values()
+                ]
+            }
+
+    async def _run_agent(
+        self, run_id: str, agent_name: str, inputs: dict[str, Any]
+    ):
+        """Execute an agent run."""
+        try:
+            # Get the agent
+            if agent_name not in self.flock.agents:
+                raise ValueError(f"Agent '{agent_name}' not found")
+
+            agent = self.flock.agents[agent_name]
+
+            # Run the agent
+            result = await agent.run_async(inputs)
+
+            # Update run status
+            self.runs[run_id].status = "completed"
+            self.runs[run_id].result = result
+            self.runs[run_id].completed_at = datetime.now()
+
+        except Exception as e:
+            logger.error(f"Error in run {run_id}: {e!s}")
+            self.runs[run_id].status = "failed"
+            self.runs[run_id].error = str(e)
+            self.runs[run_id].completed_at = datetime.now()
+
+    async def _run_flock(
+        self, run_id: str, agent_name: str, inputs: dict[str, Any]
+    ):
+        """Execute an agent run."""
+        try:
+            # Get the agent
+            if agent_name not in self.flock.agents:
+                raise ValueError(f"Agent '{agent_name}' not found")
+
+            result = await self.flock.run_async(
+                start_agent=agent_name, input=inputs
+            )
+
+            # Update run status
+            self.runs[run_id].status = "completed"
+            self.runs[run_id].result = result
+            self.runs[run_id].completed_at = datetime.now()
+
+        except Exception as e:
+            logger.error(f"Error in run {run_id}: {e!s}")
+            self.runs[run_id].status = "failed"
+            self.runs[run_id].error = str(e)
+            self.runs[run_id].completed_at = datetime.now()
+
+    def start(self, host: str = "0.0.0.0", port: int = 8344):
+        """Start the API server."""
+        uvicorn.run(self.app, host=host, port=port)
+
+    async def stop(self):
+        """Stop the API server."""
+        # Cleanup if needed
+        pass

{flock_core-0.3.3.dist-info → flock_core-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.3.3
+Version: 0.3.4
 Summary: Declarative LLM Orchestration at Scale
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License-File: LICENSE
@@ -12,6 +12,7 @@ Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: devtools>=0.12.2
 Requires-Dist: dspy==2.5.42
 Requires-Dist: duckduckgo-search>=7.3.2
+Requires-Dist: fastapi>=0.115.8
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: loguru>=0.7.3
 Requires-Dist: matplotlib>=3.10.0

{flock_core-0.3.3.dist-info → flock_core-0.3.4.dist-info}/RECORD

@@ -9,9 +9,10 @@ flock/cli/load_flock.py,sha256=3JdECvt5X7uyOG2vZS3-Zk5C5SI_84_QZjcsB3oJmfA,932
 flock/cli/load_release_notes.py,sha256=qFcgUrMddAE_TP6x1P-6ZywTUjTknfhTDW5LTxtg1yk,599
 flock/cli/settings.py,sha256=DkeLUlrb7rGx3nZ04aADU9HXXu5mZTf_DBwT0xhzIv4,7
 flock/cli/assets/release_notes.md,sha256=K-upUm5vuUuRSSU2FkMdgDfai_YlDk_vTCp0s4s2WO0,3419
-flock/core/__init__.py,sha256=ZTp6qNY-kNH_Xn0xFfCAYceYqWFdahXYMm5wWPb30Go,501
-flock/core/flock.py,sha256=4Kcnw39YiPRND6U8TWLZ0LyjNTykIk56VPruUEGwBrk,19116
+flock/core/__init__.py,sha256=mPlvKc0SxC2qCvSlgYeP_7EyV8ptmdn24NO8mlQoCSo,559
+flock/core/flock.py,sha256=1LPMblsvT90Na35LXx0w3Us66yIaTzsokL7lF5fsVX8,19228
 flock/core/flock_agent.py,sha256=RzKX0GRrRJz16YbQFheMo8TqJPXOZSHWNloTbp35zwI,12229
+flock/core/flock_api.py,sha256=SKQVKgFCaNCqHtwvIcksnpqG6ajHodVhs3oaKUw-d8c,7192
 flock/core/flock_evaluator.py,sha256=j7riJj_KsWoBnKmLiGp-U0CRhxDyJbgEdLGN26tfKm8,1588
 flock/core/flock_factory.py,sha256=vyDq0eyFT4MyE_n2JyNU7YaFx2ljmjSDmZ07OIsmIOE,2694
 flock/core/flock_module.py,sha256=VWFlBiY2RHZLTlGYfcchuT41M3m_JrZcmzw07u7KayM,2581
@@ -395,8 +396,8 @@ flock/workflow/activities.py,sha256=2zcYyDoCuYs9oQbnhLjCzBUdEi7d5IEIemKJ7TV_B8w,
 flock/workflow/agent_activities.py,sha256=NhBZscflEf2IMfSRa_pBM_TRP7uVEF_O0ROvWZ33eDc,963
 flock/workflow/temporal_setup.py,sha256=VWBgmBgfTBjwM5ruS_dVpA5AVxx6EZ7oFPGw4j3m0l0,1091
 flock/workflow/workflow.py,sha256=I9MryXW_bqYVTHx-nl2epbTqeRy27CAWHHA7ZZA0nAk,1696
-flock_core-0.3.3.dist-info/METADATA,sha256=DmDTXx-eJoRlsZbhPGsyX-OEBZ16ahgDPFKb5N0YFBk,20431
-flock_core-0.3.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.3.3.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
-flock_core-0.3.3.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
-flock_core-0.3.3.dist-info/RECORD,,
+flock_core-0.3.4.dist-info/METADATA,sha256=o10aq5iiMQPy1xhMv89xMcspa5pgX2c3lHZghImgWjo,20463
+flock_core-0.3.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.3.4.dist-info/entry_points.txt,sha256=rWaS5KSpkTmWySURGFZk6PhbJ87TmvcFQDi2uzjlagQ,37
+flock_core-0.3.4.dist-info/licenses/LICENSE,sha256=iYEqWy0wjULzM9GAERaybP4LBiPeu7Z1NEliLUdJKSc,1072
+flock_core-0.3.4.dist-info/RECORD,,