flock-core 0.5.10__py3-none-any.whl → 0.5.11__py3-none-any.whl

flock/api_models.py

@@ -0,0 +1,285 @@
+"""Pydantic response models for Flock REST API.
+
+Provides proper OpenAPI schemas for all public API endpoints.
+This improves API documentation and enables SDK generation.
+
+All models maintain 100% backwards compatibility with existing wire format.
+"""
+
+from datetime import datetime
+from typing import Any, Literal
+from uuid import UUID
+
+from pydantic import BaseModel, Field
+
+
+# ============================================================================
+# Agent Models
+# ============================================================================
+
+
+class AgentSubscription(BaseModel):
+    """Subscription configuration for an agent."""
+
+    types: list[str] = Field(description="Artifact types this subscription consumes")
+    mode: str = Field(description="Subscription mode (e.g., 'all', 'any')")
+    delivery: str = Field(description="Delivery mode (e.g., 'immediate', 'batch')")
+
+
+class Agent(BaseModel):
+    """Single agent representation."""
+
+    name: str = Field(description="Unique name of the agent")
+    description: str = Field(default="", description="Human-readable description")
+    subscriptions: list[AgentSubscription] = Field(
+        description="List of subscriptions this agent listens to"
+    )
+    outputs: list[str] = Field(description="Artifact types this agent can produce")
+
+
+class AgentListResponse(BaseModel):
+    """Response for GET /api/v1/agents."""
+
+    agents: list[Agent] = Field(description="List of all registered agents")
+
+
+# ============================================================================
+# Artifact Models
+# ============================================================================
+
+
+class VisibilityInfo(BaseModel):
+    """Artifact visibility configuration."""
+
+    kind: str = Field(description="Visibility kind (e.g., 'Public', 'Private')")
+    # Additional visibility fields added dynamically
+
+
+class ArtifactBase(BaseModel):
+    """Base artifact representation with common fields."""
+
+    id: str = Field(description="Unique artifact identifier (UUID)")
+    type: str = Field(description="Artifact type name")
+    payload: dict[str, Any] = Field(description="Artifact payload data")
+    produced_by: str = Field(description="Name of agent/source that produced this")
+    visibility: dict[str, Any] = Field(description="Visibility configuration")
+    visibility_kind: str = Field(description="Visibility kind (Public/Private/etc)")
+    created_at: str = Field(
+        description="Timestamp when artifact was created (ISO 8601)"
+    )
+    correlation_id: str | None = Field(
+        None, description="Optional correlation ID for workflow tracking"
+    )
+    partition_key: str | None = Field(None, description="Optional partition key")
+    tags: list[str] = Field(default_factory=list, description="List of tags")
+    version: int = Field(description="Artifact version number")
+
+
+class ConsumptionRecord(BaseModel):
+    """Record of an artifact being consumed by an agent."""
+
+    artifact_id: str = Field(description="ID of the artifact that was consumed")
+    consumer: str = Field(description="Name of the agent that consumed it")
+    run_id: str = Field(description="Run ID of the consumption")
+    correlation_id: str = Field(description="Correlation ID of the consumption")
+    consumed_at: str = Field(description="Timestamp of consumption (ISO 8601)")
+
+
+class ArtifactWithConsumptions(ArtifactBase):
+    """Artifact with consumption metadata included."""
+
+    consumptions: list[ConsumptionRecord] = Field(
+        default_factory=list, description="List of consumption records"
+    )
+    consumed_by: list[str] = Field(
+        default_factory=list,
+        description="List of unique agent names that consumed this artifact",
+    )
+
+
+class PaginationInfo(BaseModel):
+    """Pagination metadata."""
+
+    limit: int = Field(description="Number of items per page")
+    offset: int = Field(description="Offset into the result set")
+    total: int = Field(description="Total number of items matching the query")
+
+
+class ArtifactListResponse(BaseModel):
+    """Response for GET /api/v1/artifacts."""
+
+    items: list[ArtifactBase | ArtifactWithConsumptions] = Field(
+        description="List of artifacts (may include consumption data if embed_meta=true)"
+    )
+    pagination: PaginationInfo = Field(description="Pagination information")
+
+
+class ArtifactPublishRequest(BaseModel):
+    """Request body for POST /api/v1/artifacts."""
+
+    type: str = Field(description="Artifact type name")
+    payload: dict[str, Any] = Field(
+        default_factory=dict, description="Artifact payload data"
+    )
+
+
+class ArtifactPublishResponse(BaseModel):
+    """Response for POST /api/v1/artifacts."""
+
+    status: Literal["accepted"] = Field(description="Publication status")
+
+
+class ArtifactSummary(BaseModel):
+    """Summary statistics for artifacts."""
+
+    # Define based on actual summary structure from store
+    # This is a placeholder - update based on actual implementation
+
+
+class ArtifactSummaryResponse(BaseModel):
+    """Response for GET /api/v1/artifacts/summary."""
+
+    summary: dict[str, Any] = Field(description="Summary statistics")
+
+
+# ============================================================================
+# Agent Run Models
+# ============================================================================
+
+
+class AgentRunInput(BaseModel):
+    """Input artifact for agent run."""
+
+    type: str = Field(description="Artifact type name")
+    payload: dict[str, Any] = Field(
+        default_factory=dict, description="Artifact payload data"
+    )
+
+
+class AgentRunRequest(BaseModel):
+    """Request body for POST /api/v1/agents/{name}/run."""
+
+    inputs: list[AgentRunInput] = Field(
+        default_factory=list, description="List of input artifacts"
+    )
+
+
+class ProducedArtifact(BaseModel):
+    """Artifact produced by agent run."""
+
+    id: str = Field(description="Artifact ID (UUID)")
+    type: str = Field(description="Artifact type name")
+    payload: dict[str, Any] = Field(description="Artifact payload data")
+    produced_by: str = Field(description="Name of agent that produced this")
+
+
+class AgentRunResponse(BaseModel):
+    """Response for POST /api/v1/agents/{name}/run."""
+
+    artifacts: list[ProducedArtifact] = Field(
+        description="Artifacts produced by the agent run"
+    )
+
+
+# ============================================================================
+# Schema Discovery Models
+# ============================================================================
+
+
+class ArtifactTypeSchema(BaseModel):
+    """Schema information for an artifact type."""
+
+    model_config = {"populate_by_name": True}  # Allow using 'schema' as field name
+
+    name: str = Field(description="Type name")
+    schema_: dict[str, Any] = Field(
+        alias="schema", description="JSON Schema for this type"
+    )
+
+
+class ArtifactTypesResponse(BaseModel):
+    """Response for GET /api/artifact-types."""
+
+    artifact_types: list[ArtifactTypeSchema] = Field(
+        description="List of all registered artifact types with their schemas"
+    )
+
+
+# ============================================================================
+# Agent History Models
+# ============================================================================
+
+
+class AgentHistorySummary(BaseModel):
+    """Summary of agent execution history."""
+
+    agent_id: str = Field(description="Agent identifier")
+    summary: dict[str, Any] = Field(description="History summary statistics")
+
+
+# ============================================================================
+# Correlation Status Models
+# ============================================================================
+
+
+class CorrelationStatusResponse(BaseModel):
+    """Response for GET /api/v1/correlations/{correlation_id}/status."""
+
+    correlation_id: str = Field(description="The correlation ID")
+    state: Literal["active", "completed", "failed", "not_found"] = Field(
+        description="Workflow state: active (work pending), completed (success), failed (only errors), not_found (no artifacts)"
+    )
+    has_pending_work: bool = Field(
+        description="Whether the orchestrator has pending work for this correlation"
+    )
+    artifact_count: int = Field(
+        description="Total number of artifacts with this correlation_id"
+    )
+    error_count: int = Field(description="Number of WorkflowError artifacts")
+    started_at: str | None = Field(
+        None, description="Timestamp of first artifact (ISO 8601)"
+    )
+    last_activity_at: str | None = Field(
+        None, description="Timestamp of most recent artifact (ISO 8601)"
+    )
+
+
+# ============================================================================
+# Health & Metrics Models
+# ============================================================================
+
+
+class HealthResponse(BaseModel):
+    """Response for GET /health."""
+
+    status: Literal["ok"] = Field(description="Health status")
+
+
+__all__ = [
+    # Agent models
+    "Agent",
+    "AgentSubscription",
+    "AgentListResponse",
+    # Artifact models
+    "ArtifactBase",
+    "ArtifactWithConsumptions",
+    "ArtifactListResponse",
+    "ArtifactPublishRequest",
+    "ArtifactPublishResponse",
+    "ArtifactSummaryResponse",
+    "PaginationInfo",
+    "ConsumptionRecord",
+    # Agent run models
+    "AgentRunRequest",
+    "AgentRunResponse",
+    "ProducedArtifact",
+    # Schema discovery
+    "ArtifactTypesResponse",
+    "ArtifactTypeSchema",
+    # History
+    "AgentHistorySummary",
+    # Correlation status
+    "CorrelationStatusResponse",
+    # Health
+    "HealthResponse",
+]

flock/dashboard/service.py

@@ -19,6 +19,7 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 from pydantic import ValidationError
 
+from flock.api_models import ArtifactTypeSchema, ArtifactTypesResponse
 from flock.dashboard.collector import DashboardEventCollector
 from flock.dashboard.events import MessagePublishedEvent, VisibilitySpec
 from flock.dashboard.graph_builder import GraphAssembler
@@ -61,6 +62,18 @@ class DashboardHTTPService(BlackboardHTTPService):
         # Initialize base service
         super().__init__(orchestrator)
 
+        # Add dashboard-specific tags to OpenAPI
+        self.app.openapi_tags.extend([
+            {
+                "name": "Dashboard UI",
+                "description": "**Internal endpoints** used by the Flock dashboard UI. Not intended for direct use.",
+            },
+            {
+                "name": "Schema Discovery",
+                "description": "Endpoints for discovering available artifact types and their schemas.",
+            },
+        ])
+
         # Initialize WebSocket manager and event collector
         self.websocket_manager = websocket_manager or WebSocketManager()
         self.event_collector = event_collector or DashboardEventCollector(
@@ -137,7 +150,11 @@ class DashboardHTTPService(BlackboardHTTPService):
 
         if self.graph_assembler is not None:
 
-            @app.post("/api/dashboard/graph", response_model=GraphSnapshot)
+            @app.post(
+                "/api/dashboard/graph",
+                response_model=GraphSnapshot,
+                tags=["Dashboard UI"],
+            )
             async def get_dashboard_graph(request: GraphRequest) -> GraphSnapshot:
                 """Return server-side assembled dashboard graph snapshot."""
                 return await self.graph_assembler.build_snapshot(request)
@@ -174,8 +191,12 @@ class DashboardHTTPService(BlackboardHTTPService):
         app = self.app
         orchestrator = self.orchestrator
 
-        @app.get("/api/artifact-types")
-        async def get_artifact_types() -> dict[str, Any]:
+        @app.get(
+            "/api/artifact-types",
+            response_model=ArtifactTypesResponse,
+            tags=["Schema Discovery"],
+        )
+        async def get_artifact_types() -> ArtifactTypesResponse:
             """Get all registered artifact types with their schemas.
 
             Returns:
@@ -196,13 +217,15 @@ class DashboardHTTPService(BlackboardHTTPService):
                     model_class = type_registry.resolve(type_name)
                     # Get Pydantic schema
                     schema = model_class.model_json_schema()
-                    artifact_types.append({"name": type_name, "schema": schema})
+                    artifact_types.append(
+                        ArtifactTypeSchema(name=type_name, schema=schema)
+                    )
                 except Exception as e:
                     logger.warning(f"Could not get schema for {type_name}: {e}")
 
-            return {"artifact_types": artifact_types}
+            return ArtifactTypesResponse(artifact_types=artifact_types)
 
-        @app.get("/api/agents")
+        @app.get("/api/agents", tags=["Dashboard UI"])
         async def get_agents() -> dict[str, Any]:
             """Get all registered agents with logic operations state.
 
@@ -269,7 +292,7 @@ class DashboardHTTPService(BlackboardHTTPService):
 
             return {"agents": agents}
 
-        @app.get("/api/version")
+        @app.get("/api/version", tags=["Dashboard UI"])
         async def get_version() -> dict[str, str]:
             """Get version information for the backend and dashboard.
 
@@ -287,7 +310,7 @@ class DashboardHTTPService(BlackboardHTTPService):
 
             return {"backend_version": backend_version, "package_name": "flock-flow"}
 
-        @app.post("/api/control/publish")
+        @app.post("/api/control/publish", tags=["Dashboard UI"])
         async def publish_artifact(body: dict[str, Any]) -> dict[str, str]:
             """Publish artifact with correlation tracking.
 
@@ -363,7 +386,7 @@ class DashboardHTTPService(BlackboardHTTPService):
                 logger.exception(f"Error publishing artifact: {e}")
                 raise HTTPException(status_code=500, detail=str(e))
 
-        @app.post("/api/control/invoke")
+        @app.post("/api/control/invoke", tags=["Dashboard UI"])
         async def invoke_agent(body: dict[str, Any]) -> dict[str, Any]:
             """Directly invoke a specific agent.
 
@@ -447,7 +470,7 @@ class DashboardHTTPService(BlackboardHTTPService):
                 logger.exception(f"Error invoking agent: {e}")
                 raise HTTPException(status_code=500, detail=str(e))
 
-        @app.post("/api/control/pause")
+        @app.post("/api/control/pause", tags=["Dashboard UI"])
         async def pause_orchestrator() -> dict[str, Any]:
             """Pause orchestrator (placeholder).
 
@@ -458,7 +481,7 @@ class DashboardHTTPService(BlackboardHTTPService):
                 status_code=501, detail="Pause functionality coming in Phase 12"
             )
 
-        @app.post("/api/control/resume")
+        @app.post("/api/control/resume", tags=["Dashboard UI"])
         async def resume_orchestrator() -> dict[str, Any]:
             """Resume orchestrator (placeholder).
 
@@ -469,7 +492,7 @@ class DashboardHTTPService(BlackboardHTTPService):
                 status_code=501, detail="Resume functionality coming in Phase 12"
             )
 
-        @app.get("/api/traces")
+        @app.get("/api/traces", tags=["Dashboard UI"])
         async def get_traces() -> list[dict[str, Any]]:
             """Get OpenTelemetry traces from DuckDB.
 
@@ -559,7 +582,7 @@ class DashboardHTTPService(BlackboardHTTPService):
                 logger.exception(f"Error reading traces from DuckDB: {e}")
                 return []
 
-        @app.get("/api/traces/services")
+        @app.get("/api/traces/services", tags=["Dashboard UI"])
         async def get_trace_services() -> dict[str, Any]:
             """Get list of unique services that have been traced.
 
@@ -605,7 +628,7 @@ class DashboardHTTPService(BlackboardHTTPService):
                 logger.exception(f"Error reading trace services: {e}")
                 return {"services": [], "operations": []}
 
-        @app.post("/api/traces/clear")
+        @app.post("/api/traces/clear", tags=["Dashboard UI"])
         async def clear_traces() -> dict[str, Any]:
             """Clear all traces from DuckDB database.
 
@@ -624,7 +647,7 @@ class DashboardHTTPService(BlackboardHTTPService):
 
             return result
 
-        @app.post("/api/traces/query")
+        @app.post("/api/traces/query", tags=["Dashboard UI"])
         async def execute_trace_query(request: dict[str, Any]) -> dict[str, Any]:
             """
             Execute a DuckDB SQL query on the traces database.
@@ -705,7 +728,7 @@ class DashboardHTTPService(BlackboardHTTPService):
                 logger.exception(f"DuckDB query error: {e}")
                 return {"error": str(e), "results": [], "columns": []}
 
-        @app.get("/api/traces/stats")
+        @app.get("/api/traces/stats", tags=["Dashboard UI"])
         async def get_trace_stats() -> dict[str, Any]:
             """Get statistics about the trace database.
 
@@ -795,7 +818,7 @@ class DashboardHTTPService(BlackboardHTTPService):
                     "database_size_mb": 0,
                 }
 
-        @app.get("/api/streaming-history/{agent_name}")
+        @app.get("/api/streaming-history/{agent_name}", tags=["Dashboard UI"])
         async def get_streaming_history(agent_name: str) -> dict[str, Any]:
             """Get historical streaming output for a specific agent.
 
@@ -834,7 +857,7 @@ class DashboardHTTPService(BlackboardHTTPService):
                     status_code=500, detail=f"Failed to get streaming history: {e!s}"
                 )
 
-        @app.get("/api/artifacts/history/{node_id}")
+        @app.get("/api/artifacts/history/{node_id}", tags=["Dashboard UI"])
         async def get_message_history(node_id: str) -> dict[str, Any]:
             """Get complete message history for a node (both produced and consumed).
 
@@ -931,7 +954,7 @@ class DashboardHTTPService(BlackboardHTTPService):
                     status_code=500, detail=f"Failed to get message history: {e!s}"
                 )
 
-        @app.get("/api/agents/{agent_id}/runs")
+        @app.get("/api/agents/{agent_id}/runs", tags=["Dashboard UI"])
         async def get_agent_runs(agent_id: str) -> dict[str, Any]:
             """Get run history for an agent.
 
@@ -991,7 +1014,7 @@ class DashboardHTTPService(BlackboardHTTPService):
         app = self.app
         themes_dir = Path(__file__).parent.parent / "themes"
 
-        @app.get("/api/themes")
+        @app.get("/api/themes", tags=["Dashboard UI"])
         async def list_themes() -> dict[str, Any]:
             """Get list of available theme names.
 
@@ -1012,7 +1035,7 @@ class DashboardHTTPService(BlackboardHTTPService):
                     status_code=500, detail=f"Failed to list themes: {e!s}"
                 )
 
-        @app.get("/api/themes/{theme_name}")
+        @app.get("/api/themes/{theme_name}", tags=["Dashboard UI"])
         async def get_theme(theme_name: str) -> dict[str, Any]:
             """Get theme data by name.
 

flock/orchestrator.py

@@ -11,7 +11,7 @@ from contextlib import asynccontextmanager
 from datetime import UTC, datetime
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
-from uuid import uuid4
+from uuid import UUID, uuid4
 
 from opentelemetry import trace
 from opentelemetry.trace import Status, StatusCode
@@ -137,6 +137,9 @@ class Flock(metaclass=AutoTracedMeta):
         self.store: BlackboardStore = store or InMemoryBlackboardStore()
         self._agents: dict[str, Agent] = {}
         self._tasks: set[Task[Any]] = set()
+        self._correlation_tasks: dict[
+            UUID, set[Task[Any]]
+        ] = {}  # Track tasks by correlation_id
         self._processed: set[tuple[str, str]] = set()
         self._lock = asyncio.Lock()
         self.metrics: dict[str, float] = {"artifacts_published": 0, "agent_runs": 0}
@@ -163,6 +166,9 @@ class Flock(metaclass=AutoTracedMeta):
         self._batch_timeout_interval: float = 0.1  # Check every 100ms
         # Phase 1.2: WebSocket manager for real-time dashboard events (set by serve())
         self._websocket_manager: Any = None
+        # Dashboard server task and launcher (for non-blocking serve)
+        self._server_task: Task[None] | None = None
+        self._dashboard_launcher: Any = None
         # Unified tracing support
         self._workflow_span = None
         self._auto_workflow_enabled = os.getenv(
@@ -242,6 +248,99 @@ class Flock(metaclass=AutoTracedMeta):
     def agents(self) -> list[Agent]:
         return list(self._agents.values())
 
+    async def get_correlation_status(self, correlation_id: str) -> dict[str, Any]:
+        """Get the status of a workflow by correlation ID.
+
+        Args:
+            correlation_id: The correlation ID to check
+
+        Returns:
+            Dictionary containing workflow status information:
+            - state: "active" if work is pending, "completed" otherwise
+            - has_pending_work: True if orchestrator has pending work for this correlation
+            - artifact_count: Total number of artifacts with this correlation_id
+            - error_count: Number of WorkflowError artifacts
+            - started_at: Timestamp of first artifact (if any)
+            - last_activity_at: Timestamp of most recent artifact (if any)
+        """
+        from uuid import UUID
+
+        try:
+            correlation_uuid = UUID(correlation_id)
+        except ValueError as exc:
+            raise ValueError(
+                f"Invalid correlation_id format: {correlation_id}"
+            ) from exc
+
+        # Check if orchestrator has pending work for this correlation
+        # 1. Check active tasks for this correlation_id
+        has_active_tasks = correlation_uuid in self._correlation_tasks and bool(
+            self._correlation_tasks[correlation_uuid]
+        )
+
+        # 2. Check correlation groups (for agents with JoinSpec that haven't yielded yet)
+        has_pending_groups = False
+        for groups in self._correlation_engine.correlation_groups.values():
+            for group_key, group in groups.items():
+                # Check if this group belongs to our correlation
+                for type_name, artifacts in group.waiting_artifacts.items():
+                    if any(
+                        artifact.correlation_id == correlation_uuid
+                        for artifact in artifacts
+                    ):
+                        has_pending_groups = True
+                        break
+                if has_pending_groups:
+                    break
+            if has_pending_groups:
+                break
+
+        # Workflow has pending work if EITHER tasks are active OR groups are waiting
+        has_pending_work = has_active_tasks or has_pending_groups
+
+        # Query artifacts for this correlation
+        from flock.store import FilterConfig
+
+        filters = FilterConfig(correlation_id=correlation_id)
+        artifacts, total = await self.store.query_artifacts(
+            filters, limit=1000, offset=0
+        )
+
+        # Count errors
+        error_count = sum(
+            1
+            for artifact in artifacts
+            if artifact.type == "flock.system_artifacts.WorkflowError"
+        )
+
+        # Get timestamps
+        started_at = None
+        last_activity_at = None
+        if artifacts:
+            timestamps = [artifact.created_at for artifact in artifacts]
+            started_at = min(timestamps).isoformat()
+            last_activity_at = max(timestamps).isoformat()
+
+        # Determine state
+        if has_pending_work:
+            state = "active"
+        elif total == 0:
+            state = "not_found"
+        elif error_count > 0 and total == error_count:
+            state = "failed"  # Only error artifacts exist
+        else:
+            state = "completed"
+
+        return {
+            "correlation_id": correlation_id,
+            "state": state,
+            "has_pending_work": has_pending_work,
+            "artifact_count": total,
+            "error_count": error_count,
+            "started_at": started_at,
+            "last_activity_at": last_activity_at,
+        }
+
     # Component management -------------------------------------------------
 
     def add_component(self, component: OrchestratorComponent) -> Flock:
@@ -742,6 +841,15 @@ class Flock(metaclass=AutoTracedMeta):
             except asyncio.CancelledError:
                 pass
 
+        # Cancel background server task if running
+        if self._server_task and not self._server_task.done():
+            self._server_task.cancel()
+            try:
+                await self._server_task
+            except asyncio.CancelledError:
+                pass
+            # Note: _cleanup_server_callback will handle launcher.stop()
+
         if self._mcp_manager is not None:
             await self._mcp_manager.cleanup_all()
             self._mcp_manager = None
@@ -757,14 +865,20 @@ class Flock(metaclass=AutoTracedMeta):
         dashboard_v2: bool = False,
         host: str = "127.0.0.1",
         port: int = 8344,
-    ) -> None:
-        """Start HTTP service for the orchestrator (blocking).
+        blocking: bool = True,
+    ) -> Task[None] | None:
+        """Start HTTP service for the orchestrator.
 
         Args:
             dashboard: Enable real-time dashboard with WebSocket support (default: False)
             dashboard_v2: Launch the new dashboard v2 frontend (implies dashboard=True)
             host: Host to bind to (default: "127.0.0.1")
             port: Port to bind to (default: 8344)
+            blocking: If True, blocks until server stops. If False, starts server
+                in background and returns task handle (default: True)
+
+        Returns:
+            None if blocking=True, or Task handle if blocking=False
 
         Examples:
             # Basic HTTP API (no dashboard) - runs until interrupted
@@ -772,7 +886,75 @@ class Flock(metaclass=AutoTracedMeta):
 
             # With dashboard (WebSocket + browser launch) - runs until interrupted
             await orchestrator.serve(dashboard=True)
+
+            # Non-blocking mode - start server in background
+            await orchestrator.serve(dashboard=True, blocking=False)
+            # Now you can publish messages and run other logic
+            await orchestrator.publish(my_message)
+            await orchestrator.run_until_idle()
         """
+        # If non-blocking, start server in background task
+        if not blocking:
+            self._server_task = asyncio.create_task(
+                self._serve_impl(
+                    dashboard=dashboard,
+                    dashboard_v2=dashboard_v2,
+                    host=host,
+                    port=port,
+                )
+            )
+            # Add cleanup callback
+            self._server_task.add_done_callback(self._cleanup_server_callback)
+            # Give server a moment to start
+            await asyncio.sleep(0.1)
+            return self._server_task
+
+        # Blocking mode - run server directly with cleanup
+        try:
+            await self._serve_impl(
+                dashboard=dashboard,
+                dashboard_v2=dashboard_v2,
+                host=host,
+                port=port,
+            )
+        finally:
+            # In blocking mode, manually cleanup dashboard launcher
+            if self._dashboard_launcher is not None:
+                self._dashboard_launcher.stop()
+                self._dashboard_launcher = None
+        return None
+
+    def _cleanup_server_callback(self, task: Task[None]) -> None:
+        """Cleanup callback when background server task completes."""
+        # Stop dashboard launcher if it was started
+        if self._dashboard_launcher is not None:
+            try:
+                self._dashboard_launcher.stop()
+            except Exception as e:
+                self._logger.warning(f"Failed to stop dashboard launcher: {e}")
+            finally:
+                self._dashboard_launcher = None
+
+        # Clear server task reference
+        self._server_task = None
+
+        # Log any exceptions from the task
+        try:
+            exc = task.exception()
+            if exc and not isinstance(exc, asyncio.CancelledError):
+                self._logger.error(f"Server task failed: {exc}", exc_info=exc)
+        except asyncio.CancelledError:
+            pass  # Normal cancellation
+
+    async def _serve_impl(
+        self,
+        *,
+        dashboard: bool = False,
+        dashboard_v2: bool = False,
+        host: str = "127.0.0.1",
+        port: int = 8344,
+    ) -> None:
+        """Internal implementation of serve() - actual server logic."""
         if dashboard_v2:
             dashboard = True
 
@@ -837,11 +1019,8 @@ class Flock(metaclass=AutoTracedMeta):
         self._dashboard_launcher = launcher
 
         # Run service (blocking call)
-        try:
-            await service.run_async(host=host, port=port)
-        finally:
-            # Cleanup on exit
-            launcher.stop()
+        # Note: Cleanup is handled by serve() (blocking mode) or callback (non-blocking mode)
+        await service.run_async(host=host, port=port)
 
     # Scheduling -----------------------------------------------------------
 
@@ -1419,6 +1598,24 @@ class Flock(metaclass=AutoTracedMeta):
         )
         self._tasks.add(task)
         task.add_done_callback(self._tasks.discard)
+
+        # Track task by correlation_id for workflow status tracking
+        correlation_id = artifacts[0].correlation_id if artifacts else None
+        if correlation_id:
+            if correlation_id not in self._correlation_tasks:
+                self._correlation_tasks[correlation_id] = set()
+            self._correlation_tasks[correlation_id].add(task)
+
+            # Clean up correlation tracking when task completes
+            def cleanup_correlation(t: Task[Any]) -> None:
+                if correlation_id in self._correlation_tasks:
+                    self._correlation_tasks[correlation_id].discard(t)
+                    # Remove empty sets to prevent memory leaks
+                    if not self._correlation_tasks[correlation_id]:
+                        del self._correlation_tasks[correlation_id]
+
+            task.add_done_callback(cleanup_correlation)
+
         return task
 
     def _record_agent_run(self, agent: Agent) -> None:
@@ -1477,7 +1674,47 @@ class Flock(metaclass=AutoTracedMeta):
         self._record_agent_run(agent)
 
         # Phase 6: Execute agent (returns artifacts, doesn't publish)
-        outputs = await agent.execute(ctx, artifacts)
+        # Wrap in try/catch to handle agent failures gracefully
+        try:
+            outputs = await agent.execute(ctx, artifacts)
+        except asyncio.CancelledError:
+            # Re-raise cancellations immediately (shutdown, user cancellation)
+            # Do NOT treat these as errors - they're intentional interruptions
+            self._logger.debug(
+                f"Agent '{agent.name}' task cancelled (task={ctx.task_id})"
+            )
+            raise  # Propagate cancellation so task.cancelled() == True
+        except Exception as exc:
+            # Agent already called component.on_error hooks before re-raising
+            # Now orchestrator publishes error artifact and continues workflow
+            from flock.system_artifacts import WorkflowError
+
+            error_artifact_data = WorkflowError(
+                failed_agent=agent.name,
+                error_type=type(exc).__name__,
+                error_message=str(exc),
+                timestamp=datetime.now(UTC),
+                task_id=ctx.task_id,
+            )
+
+            # Build and publish error artifact with correlation_id
+            from flock.artifacts import ArtifactSpec
+
+            error_spec = ArtifactSpec.from_model(WorkflowError)
+            error_artifact = error_spec.build(
+                produced_by=f"orchestrator#{agent.name}",
+                data=error_artifact_data.model_dump(),
+                correlation_id=correlation_id,
+            )
+
+            await self._persist_and_schedule(error_artifact)
+
+            # Log error but don't re-raise - workflow continues
+            self._logger.error(
+                f"Agent '{agent.name}' failed (task={ctx.task_id}): {exc}",
+                exc_info=True,
+            )
+            return  # Exit early - no outputs to publish
 
         # Phase 6: Orchestrator publishes outputs (security fix)
         # This fixes Vulnerability #2 (WRITE Bypass) - agents can't bypass validation

flock/service.py

@@ -10,6 +10,20 @@ from uuid import UUID
 from fastapi import FastAPI, HTTPException, Query
 from fastapi.responses import PlainTextResponse
 
+from flock.api_models import (
+    Agent,
+    AgentListResponse,
+    AgentRunRequest,
+    AgentRunResponse,
+    AgentSubscription,
+    ArtifactListResponse,
+    ArtifactPublishRequest,
+    ArtifactPublishResponse,
+    ArtifactSummaryResponse,
+    CorrelationStatusResponse,
+    HealthResponse,
+    ProducedArtifact,
+)
 from flock.registry import type_registry
 from flock.store import ArtifactEnvelope, ConsumptionRecord, FilterConfig
 
@@ -21,7 +35,21 @@ if TYPE_CHECKING:
 class BlackboardHTTPService:
     def __init__(self, orchestrator: Flock) -> None:
         self.orchestrator = orchestrator
-        self.app = FastAPI(title="Blackboard Agents Service", version="1.0.0")
+        self.app = FastAPI(
+            title="Flock REST API Documentation",
+            version="1.0.0",
+            description="RESTful API for interacting with Flock agents and artifacts",
+            openapi_tags=[
+                {
+                    "name": "Public API",
+                    "description": "**Production-ready endpoints** for publishing artifacts, running agents, and querying data. Use these in your applications.",
+                },
+                {
+                    "name": "Health & Metrics",
+                    "description": "Monitoring endpoints for health checks and metrics collection.",
+                },
+            ],
+        )
         self._register_routes()
 
     def _register_routes(self) -> None:
@@ -92,19 +120,25 @@ class BlackboardHTTPService:
                 end=_parse_datetime(end, "to"),
             )
 
-        @app.post("/api/v1/artifacts")
-        async def publish_artifact(body: dict[str, Any]) -> dict[str, str]:
-            type_name = body.get("type")
-            payload = body.get("payload") or {}
-            if not type_name:
-                raise HTTPException(status_code=400, detail="type is required")
+        @app.post(
+            "/api/v1/artifacts",
+            response_model=ArtifactPublishResponse,
+            tags=["Public API"],
+        )
+        async def publish_artifact(
+            body: ArtifactPublishRequest,
+        ) -> ArtifactPublishResponse:
             try:
-                await orchestrator.publish({"type": type_name, **payload})
+                await orchestrator.publish({"type": body.type, **body.payload})
             except Exception as exc:  # pragma: no cover - FastAPI converts
                 raise HTTPException(status_code=400, detail=str(exc)) from exc
-            return {"status": "accepted"}
+            return ArtifactPublishResponse(status="accepted")
 
-        @app.get("/api/v1/artifacts")
+        @app.get(
+            "/api/v1/artifacts",
+            response_model=ArtifactListResponse,
+            tags=["Public API"],
+        )
         async def list_artifacts(
             type_names: list[str] | None = Query(None, alias="type"),
             produced_by: list[str] | None = Query(None),
@@ -116,7 +150,7 @@ class BlackboardHTTPService:
             limit: int = Query(50, ge=1, le=500),
             offset: int = Query(0, ge=0),
             embed_meta: bool = Query(False, alias="embed_meta"),
-        ) -> dict[str, Any]:
+        ) -> ArtifactListResponse:
             filters = _make_filter_config(
                 type_names,
                 produced_by,
@@ -140,12 +174,16 @@ class BlackboardHTTPService:
                     )
                 else:
                     items.append(_serialize_artifact(artifact))
-            return {
-                "items": items,
-                "pagination": {"limit": limit, "offset": offset, "total": total},
-            }
+            return ArtifactListResponse(
+                items=items,
+                pagination={"limit": limit, "offset": offset, "total": total},
+            )
 
-        @app.get("/api/v1/artifacts/summary")
+        @app.get(
+            "/api/v1/artifacts/summary",
+            response_model=ArtifactSummaryResponse,
+            tags=["Public API"],
+        )
         async def summarize_artifacts(
             type_names: list[str] | None = Query(None, alias="type"),
             produced_by: list[str] | None = Query(None),
@@ -154,7 +192,7 @@ class BlackboardHTTPService:
             start: str | None = Query(None, alias="from"),
             end: str | None = Query(None, alias="to"),
             visibility: list[str] | None = Query(None),
-        ) -> dict[str, Any]:
+        ) -> ArtifactSummaryResponse:
             filters = _make_filter_config(
                 type_names,
                 produced_by,
@@ -165,33 +203,30 @@ class BlackboardHTTPService:
                 end,
             )
             summary = await orchestrator.store.summarize_artifacts(filters)
-            return {"summary": summary}
+            return ArtifactSummaryResponse(summary=summary)
 
-        @app.get("/api/v1/artifacts/{artifact_id}")
+        @app.get("/api/v1/artifacts/{artifact_id}", tags=["Public API"])
         async def get_artifact(artifact_id: UUID) -> dict[str, Any]:
             artifact = await orchestrator.store.get(artifact_id)
             if artifact is None:
                 raise HTTPException(status_code=404, detail="artifact not found")
             return _serialize_artifact(artifact)
 
-        @app.post("/api/v1/agents/{name}/run")
-        async def run_agent(name: str, body: dict[str, Any]) -> dict[str, Any]:
+        @app.post(
+            "/api/v1/agents/{name}/run",
+            response_model=AgentRunResponse,
+            tags=["Public API"],
+        )
+        async def run_agent(name: str, body: AgentRunRequest) -> AgentRunResponse:
             try:
                 agent = orchestrator.get_agent(name)
             except KeyError as exc:
                 raise HTTPException(status_code=404, detail="agent not found") from exc
 
-            inputs_data: list[dict[str, Any]] = body.get("inputs") or []
             inputs = []
-            for item in inputs_data:
-                type_name = item.get("type")
-                payload = item.get("payload") or {}
-                if not type_name:
-                    raise HTTPException(
-                        status_code=400, detail="Each input requires 'type'."
-                    )
-                model = type_registry.resolve(type_name)
-                instance = model(**payload)
+            for item in body.inputs:
+                model = type_registry.resolve(item.type)
+                instance = model(**item.payload)
                 inputs.append(instance)
 
             try:
@@ -201,40 +236,42 @@ class BlackboardHTTPService:
                     status_code=500, detail=f"Agent execution failed: {exc}"
                 ) from exc
 
-            return {
-                "artifacts": [
-                    {
-                        "id": str(artifact.id),
-                        "type": artifact.type,
-                        "payload": artifact.payload,
-                        "produced_by": artifact.produced_by,
-                    }
+            return AgentRunResponse(
+                artifacts=[
+                    ProducedArtifact(
+                        id=str(artifact.id),
+                        type=artifact.type,
+                        payload=artifact.payload,
+                        produced_by=artifact.produced_by,
+                    )
                     for artifact in outputs
                 ]
-            }
+            )
 
-        @app.get("/api/v1/agents")
-        async def list_agents() -> dict[str, Any]:
-            return {
-                "agents": [
-                    {
-                        "name": agent.name,
-                        "description": agent.description,
-                        "subscriptions": [
-                            {
-                                "types": list(subscription.type_names),
-                                "mode": subscription.mode,
-                                "delivery": subscription.delivery,
-                            }
+        @app.get(
+            "/api/v1/agents", response_model=AgentListResponse, tags=["Public API"]
+        )
+        async def list_agents() -> AgentListResponse:
+            return AgentListResponse(
+                agents=[
+                    Agent(
+                        name=agent.name,
+                        description=agent.description or "",
+                        subscriptions=[
+                            AgentSubscription(
+                                types=list(subscription.type_names),
+                                mode=subscription.mode,
+                                delivery=subscription.delivery,
+                            )
                             for subscription in agent.subscriptions
                         ],
-                        "outputs": [output.spec.type_name for output in agent.outputs],
-                    }
+                        outputs=[output.spec.type_name for output in agent.outputs],
+                    )
                     for agent in orchestrator.agents
                 ]
-            }
+            )
 
-        @app.get("/api/v1/agents/{agent_id}/history-summary")
+        @app.get("/api/v1/agents/{agent_id}/history-summary", tags=["Public API"])
         async def agent_history(
             agent_id: str,
             type_names: list[str] | None = Query(None, alias="type"),
@@ -257,11 +294,32 @@ class BlackboardHTTPService:
             summary = await orchestrator.store.agent_history_summary(agent_id, filters)
             return {"agent_id": agent_id, "summary": summary}
 
-        @app.get("/health")
-        async def health() -> dict[str, str]:  # pragma: no cover - trivial
-            return {"status": "ok"}
+        @app.get(
+            "/api/v1/correlations/{correlation_id}/status",
+            response_model=CorrelationStatusResponse,
+            tags=["Public API"],
+        )
+        async def get_correlation_status(
+            correlation_id: str,
+        ) -> CorrelationStatusResponse:
+            """Get the status of a workflow by correlation ID.
+
+            Returns workflow state (active/completed/failed/not_found), pending work status,
+            artifact counts, error counts, and timestamps.
+
+            This endpoint is useful for polling to check if a workflow has completed.
+            """
+            try:
+                status = await orchestrator.get_correlation_status(correlation_id)
+                return CorrelationStatusResponse(**status)
+            except ValueError as exc:
+                raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+        @app.get("/health", response_model=HealthResponse, tags=["Health & Metrics"])
+        async def health() -> HealthResponse:  # pragma: no cover - trivial
+            return HealthResponse(status="ok")
 
-        @app.get("/metrics")
+        @app.get("/metrics", tags=["Health & Metrics"])
         async def metrics() -> PlainTextResponse:
             lines = [
                 f"blackboard_{key} {value}"

flock/system_artifacts.py

@@ -0,0 +1,33 @@
+"""System-level artifact types published by the Flock orchestrator.
+
+These artifacts provide workflow telemetry and error tracking.
+"""
+
+from datetime import datetime
+
+from pydantic import BaseModel, Field
+
+from flock.registry import flock_type
+
+
+@flock_type
+class WorkflowError(BaseModel):
+    """Error artifact published when an agent execution fails.
+
+    This artifact is automatically published by the orchestrator when an agent
+    raises an exception during execution. It includes the correlation_id to enable
+    error tracking for workflows.
+
+    The workflow continues execution for other branches even when this is published.
+    """
+
+    failed_agent: str = Field(description="Name of the agent that failed")
+    error_type: str = Field(description="Type of exception that occurred")
+    error_message: str = Field(description="Error message from the exception")
+    timestamp: datetime = Field(description="When the error occurred")
+    task_id: str | None = Field(
+        default=None, description="Task ID of the failed execution"
+    )
+
+
+__all__ = ["WorkflowError"]

{flock_core-0.5.10.dist-info → flock_core-0.5.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: flock-core
-Version: 0.5.10
+Version: 0.5.11
 Summary: Flock: A declrative framework for building and orchestrating AI agents.
 Author-email: Andre Ratzenberger <andre.ratzenberger@whiteduck.de>
 License: MIT
@@ -287,63 +287,6 @@ asyncio.run(main())
 
 ---
 
-## Context Provider Primer (Security + Cost)
-
-Context Providers are the security and efficiency layer between agents and the blackboard. They decide what each agent sees in its historical context and always enforce visibility rules.
-
-Why use them
-- Enforce access control (visibility is applied before engines see data)
-- Cut context size (often 90%+) by filtering to what matters
-- Specialize per agent or set a global default
-
-Copy/paste examples
-```python
-from flock import Flock
-from flock.context_provider import FilteredContextProvider
-from flock.store import FilterConfig
-
-# Global: show only urgent items (limit context size)
-flock = Flock(
-    "openai/gpt-4.1",
-    context_provider=FilteredContextProvider(FilterConfig(tags={"urgent"}), limit=50)
-)
-
-# Per-agent: override global for a specific role
-senior = flock.agent("senior").consumes(LogEntry).publishes(Analysis)
-senior.context_provider = FilteredContextProvider(
-    FilterConfig(tags={"ERROR", "WARN"}),
-    limit=200
-)
-```
-
-Learn more: docs/guides/context-providers.md
-
----
-
-## Persistent Blackboard History
-
-The in-memory store is still great for local tinkering, but production teams now have a durable option. Plugging in `SQLiteBlackboardStore` turns the blackboard into a persistent event log with first-class ergonomics:
-
-- **Long-lived artifacts** — every field (payload, tags, partition keys, visibility) is stored for replay, audits, and postmortems
-- **Historical APIs** — `/api/v1/artifacts`, `/summary`, and `/agents/{agent_id}/history-summary` expose pagination, filtering, and consumption counts
-- **Dashboard module** — the new **Historical Blackboard** experience preloads persisted history, enriches the graph with consumer metadata, and highlights retention windows
-- **Operational tooling** — CLI helpers (`init-sqlite-store`, `sqlite-maintenance --delete-before ... --vacuum`) make schema setup and retention policies scriptable
-
-Quick start:
-
-```python
-from flock import Flock
-from flock.store import SQLiteBlackboardStore
-
-store = SQLiteBlackboardStore(".flock/blackboard.db")
-await store.ensure_schema()
-flock = Flock("openai/gpt-4.1", store=store)
-```
-
-Run `examples/02-the-blackboard/01_persistent_pizza.py` to generate history, then launch `examples/03-the-dashboard/04_persistent_pizza_dashboard.py` and explore previous runs, consumption trails, and retention banners inside the dashboard.
-
----
-
 ## Core Concepts
 
 ### Typed Artifacts (The Vocabulary)
@@ -673,6 +616,28 @@ agent.context_provider = FilteredContextProvider(
 
 **📖 [Learn more: Context Providers Guide](https://whiteducksoftware.github.io/flock/guides/context-providers/) | [Steal production code →](examples/08-context-provider/)**
 
+### Persistent Blackboard History
+
+The in-memory store is great for local development, but production teams need durability. The `SQLiteBlackboardStore` turns the blackboard into a persistent event log with first-class ergonomics:
+
+**What you get:**
+- **Long-lived artifacts** — Every field (payload, tags, partition keys, visibility) stored for replay, audits, and postmortems
+- **Historical APIs** — `/api/v1/artifacts`, `/summary`, and `/agents/{agent_id}/history-summary` expose pagination, filtering, and consumption counts
+- **Dashboard integration** — The **Historical Blackboard** view preloads persisted history, enriches the graph with consumer metadata, and highlights retention windows
+- **Operational tooling** — CLI helpers (`init-sqlite-store`, `sqlite-maintenance --delete-before ... --vacuum`) make schema setup and retention policies scriptable
+
+**Quick start:**
+```python
+from flock import Flock
+from flock.store import SQLiteBlackboardStore
+
+store = SQLiteBlackboardStore(".flock/blackboard.db")
+await store.ensure_schema()
+flock = Flock("openai/gpt-4.1", store=store)
+```
+
+**Try it:** Run `examples/02-the-blackboard/01_persistent_pizza.py` to generate history, then launch `examples/03-the-dashboard/04_persistent_pizza_dashboard.py` to explore previous runs, consumption trails, and retention banners.
+
 ### Batching Pattern: Parallel Execution Control
 
 **A key differentiator:** The separation of `publish()` and `run_until_idle()` enables parallel execution.
@@ -800,6 +765,35 @@ agent.best_of(150, ...)  # ⚠️ Warns: "best_of(150) is very high - high LLM c
 
 ## Production-Ready Observability
 
+### Sophisticated REST API
+
+**Production-ready HTTP endpoints with comprehensive OpenAPI documentation:**
+
+Flock includes a fully-featured REST API for programmatic access to the blackboard, agents, and workflow orchestration. Perfect for integration with external systems, building custom UIs, or monitoring production deployments.
+
+**Key endpoints:**
+- `POST /api/v1/artifacts` - Publish artifacts to the blackboard
+- `GET /api/v1/artifacts` - Query artifacts with filtering, pagination, and consumption metadata
+- `POST /api/v1/agents/{name}/run` - Direct agent invocation
+- `GET /api/v1/correlations/{correlation_id}/status` - Workflow completion tracking
+- `GET /api/v1/agents` - List all registered agents with subscriptions
+- `GET /health` and `GET /metrics` - Production monitoring
+
+**Start the API server:**
+```python
+await flock.serve(dashboard=True)  # API + Dashboard on port 8344
+# API docs: http://localhost:8344/docs
+```
+
+**Features:**
+- ✅ **OpenAPI 3.0** - Interactive documentation at `/docs`
+- ✅ **Pydantic validation** - Type-safe request/response models
+- ✅ **Correlation tracking** - Monitor workflow completion with polling
+- ✅ **Consumption metadata** - Full artifact lineage and agent execution trails
+- ✅ **Production monitoring** - Health checks and Prometheus-compatible metrics
+
+**📖 [Explore the API →](http://localhost:8344/docs)** (start the server first!)
+
 ### Real-Time Dashboard
 
 **Start the dashboard with one line:**

{flock_core-0.5.10.dist-info → flock_core-0.5.11.dist-info}/RECORD

@@ -1,5 +1,6 @@
 flock/__init__.py,sha256=fvp4ltfaAGmYliShuTY_XVIpOUN6bMXbWiBnwb1NBoM,310
 flock/agent.py,sha256=luggPsY2pAnjt4TQ-S-ez1us5R2qk6UC-12ccjP6cMk,62607
+flock/api_models.py,sha256=Ot8riWjpf4p94P5IsdGz1vfQOizwLFrqwyzqkZWJDjc,9536
 flock/artifact_collector.py,sha256=j9p0qvu9IrmMTvOwdX3PGhEnj1-A3uMx0bMfG9zBdgo,6410
 flock/artifacts.py,sha256=QIUlol5hzUZO_8SINCqsN_Xr8fHixsc01QbFV_WIIj0,2527
 flock/batch_accumulator.py,sha256=4ZZLERkpH0XzN87-z2b5Tyjubheo_yCxoXz4lsjxUuk,8017
@@ -8,13 +9,14 @@ flock/components.py,sha256=SpqFmYBLNIGkKkVrfGpi-9eFj7jKA0N8VJHL-HiyzRc,8092
 flock/context_provider.py,sha256=Le01ZilMobaaPqZVJiBGFWkv1XnN3K6CtnPVD5Ewphk,20245
 flock/correlation_engine.py,sha256=pFD1y13bSMZ9HpUpp6RHWr5vb39gd0mf-rRQIFI0R5Q,8055
 flock/examples.py,sha256=z83GXjtroxRKplt57ur3v8UJFwf9cCHtZ3gj7QHiigs,3688
-flock/orchestrator.py,sha256=g9Vv0Dhd1Ls_Nm_MiTFL7si4LH14owzTiM6fccX9umA,68645
+flock/orchestrator.py,sha256=UgHL6knHZy6PHRmL_GOL91xDr2wfgFv0yB7SKS8AIj4,78263
 flock/orchestrator_component.py,sha256=lBn8WXiLzw3MXcU5JrNC3uH2SruLBCj8bSnSzH9txes,25210
 flock/registry.py,sha256=eCSK1yOgcY53vzaNFG4qnlLP3H9R4NWi9fTq_WUNjus,4846
 flock/runtime.py,sha256=DCClW_53ped_M0uMravPXmEGgVn_tOsyynNVYjZyM3c,10771
-flock/service.py,sha256=lwOIlm-nSOHDnjvWFKL7vrAmk6MdGmSJVAihK0wcia4,11287
+flock/service.py,sha256=6-j2QPmtWiniZtEAfvAzdsLdEGPAfCPuwcusXFZfs1A,13341
 flock/store.py,sha256=hvecQqmx1xov7FyRCTwnyFJTpGb_7LHrHHQhGRWRUIE,46029
 flock/subscription.py,sha256=2_0jCxOlk-G1jsD6tiVILmKdmx-Wm1qGYzCZVbz_ktg,5424
+flock/system_artifacts.py,sha256=f4O-gErJRy5aMFVDh6ZGcj_5Gr130WnG28m5AfhnbxU,1083
 flock/utilities.py,sha256=PNIIBrtvwAkW6cI_OxF2dPS151ZjDNbFOaCfsul2BpE,12473
 flock/visibility.py,sha256=uwscg32t6Dp9LuA_EVDT5-_1lotzZWWS9Dl1foyJDxo,2926
 flock/api/themes.py,sha256=7L-Bxhh8N1FXYsyTy7B_n8mSCGl_wDZXrvyY2llkF-A,1938
@@ -23,7 +25,7 @@ flock/dashboard/collector.py,sha256=zMDv1OYWrDz5obNVMrc7uLImUH5yWIYCaMB0h-Uu2kY,
 flock/dashboard/events.py,sha256=ptKNaeHcgYnIO8rBTEK56ZC5w-dUWakXhNzDep1XaL4,7653
 flock/dashboard/graph_builder.py,sha256=jdiaruce5uRybndlA4aiOXW-gKkHeGtnndzYQ1WyU9Y,32006
 flock/dashboard/launcher.py,sha256=qnl1sFm9g2dAyzhyLPrfqAfld63G9aTNRHchgNuGnoo,8218
-flock/dashboard/service.py,sha256=iEhI9W7Z1Z9UHq9DLjAzvDmgaWUr0qac2FPJiu9IcDI,53607
+flock/dashboard/service.py,sha256=-ksQ12D--EAi52WPR3PgBpRig0QZL8Fd9mq5PMEDBrI,54791
 flock/dashboard/websocket.py,sha256=qv2cbX9DBhglYgGGPFsD9ryehkBsIcJQGg7tJTIDyMM,9689
 flock/dashboard/models/__init__.py,sha256=T4Yz8IXMm7lBqa2HLDSv7WJBtaKcdZIlTrz6GHNFZxs,68
 flock/dashboard/models/graph.py,sha256=mQBzaogaOV1sss4aI3yNK8Kg4SdztPwIu3VQfrB3zLU,5444
@@ -531,8 +533,8 @@ flock/themes/zenburned.toml,sha256=UEmquBbcAO3Zj652XKUwCsNoC2iQSlIh-q5c6DH-7Kc,1
 flock/themes/zenwritten-dark.toml,sha256=-dgaUfg1iCr5Dv4UEeHv_cN4GrPUCWAiHSxWK20X1kI,1663
 flock/themes/zenwritten-light.toml,sha256=G1iEheCPfBNsMTGaVpEVpDzYBHA_T-MV27rolUYolmE,1666
 flock/utility/output_utility_component.py,sha256=YXzVy4EZXTrz0o6DjlE6tna4N79T5S5b98qDS42KqXM,9316
-flock_core-0.5.10.dist-info/METADATA,sha256=STc1MF57LI48929-B1uzmvLQACqRnTQLtpz-4iXgybQ,50917
-flock_core-0.5.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-flock_core-0.5.10.dist-info/entry_points.txt,sha256=UQdPmtHd97gSA_IdLt9MOd-1rrf_WO-qsQeIiHWVrp4,42
-flock_core-0.5.10.dist-info/licenses/LICENSE,sha256=U3IZuTbC0yLj7huwJdldLBipSOHF4cPf6cUOodFiaBE,1072
-flock_core-0.5.10.dist-info/RECORD,,
+flock_core-0.5.11.dist-info/METADATA,sha256=r87xPBNRpCHFwDSyKCVDLflsouPrAO5fXPh9BN3HlB0,51253
+flock_core-0.5.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+flock_core-0.5.11.dist-info/entry_points.txt,sha256=UQdPmtHd97gSA_IdLt9MOd-1rrf_WO-qsQeIiHWVrp4,42
+flock_core-0.5.11.dist-info/licenses/LICENSE,sha256=U3IZuTbC0yLj7huwJdldLBipSOHF4cPf6cUOodFiaBE,1072
+flock_core-0.5.11.dist-info/RECORD,,