flock-core 0.5.0b63__py3-none-any.whl → 0.5.0b70__py3-none-any.whl

flock/service.py

@@ -3,13 +3,15 @@ from __future__ import annotations
 
 """HTTP control plane for the blackboard orchestrator."""
 
+from datetime import datetime
 from typing import TYPE_CHECKING, Any
 from uuid import UUID
 
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, HTTPException, Query
 from fastapi.responses import PlainTextResponse
 
 from flock.registry import type_registry
+from flock.store import ArtifactEnvelope, ConsumptionRecord, FilterConfig
 
 
 if TYPE_CHECKING:
@@ -26,6 +28,64 @@ class BlackboardHTTPService:
         app = self.app
         orchestrator = self.orchestrator
 
+        def _serialize_artifact(
+            artifact,
+            consumptions: list[ConsumptionRecord] | None = None,
+        ) -> dict[str, Any]:
+            data = {
+                "id": str(artifact.id),
+                "type": artifact.type,
+                "payload": artifact.payload,
+                "produced_by": artifact.produced_by,
+                "visibility": artifact.visibility.model_dump(mode="json"),
+                "visibility_kind": getattr(artifact.visibility, "kind", "Unknown"),
+                "created_at": artifact.created_at.isoformat(),
+                "correlation_id": str(artifact.correlation_id) if artifact.correlation_id else None,
+                "partition_key": artifact.partition_key,
+                "tags": sorted(artifact.tags),
+                "version": artifact.version,
+            }
+            if consumptions is not None:
+                data["consumptions"] = [
+                    {
+                        "artifact_id": str(record.artifact_id),
+                        "consumer": record.consumer,
+                        "run_id": record.run_id,
+                        "correlation_id": record.correlation_id,
+                        "consumed_at": record.consumed_at.isoformat(),
+                    }
+                    for record in consumptions
+                ]
+                data["consumed_by"] = sorted({record.consumer for record in consumptions})
+            return data
+
+        def _parse_datetime(value: str | None, label: str) -> datetime | None:
+            if value is None:
+                return None
+            try:
+                return datetime.fromisoformat(value)
+            except ValueError as exc:  # pragma: no cover - FastAPI converts
+                raise HTTPException(status_code=400, detail=f"Invalid {label}: {value}") from exc
+
+        def _make_filter_config(
+            type_names: list[str] | None,
+            produced_by: list[str] | None,
+            correlation_id: str | None,
+            tags: list[str] | None,
+            visibility: list[str] | None,
+            start: str | None,
+            end: str | None,
+        ) -> FilterConfig:
+            return FilterConfig(
+                type_names=set(type_names) if type_names else None,
+                produced_by=set(produced_by) if produced_by else None,
+                correlation_id=correlation_id,
+                tags=set(tags) if tags else None,
+                visibility=set(visibility) if visibility else None,
+                start=_parse_datetime(start, "from"),
+                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")
@@ -38,19 +98,73 @@ class BlackboardHTTPService:
                 raise HTTPException(status_code=400, detail=str(exc)) from exc
             return {"status": "accepted"}
 
+        @app.get("/api/v1/artifacts")
+        async def list_artifacts(
+            type_names: list[str] | None = Query(None, alias="type"),
+            produced_by: list[str] | None = Query(None),
+            correlation_id: str | None = None,
+            tag: list[str] | None = Query(None),
+            start: str | None = Query(None, alias="from"),
+            end: str | None = Query(None, alias="to"),
+            visibility: list[str] | None = Query(None),
+            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]:
+            filters = _make_filter_config(
+                type_names,
+                produced_by,
+                correlation_id,
+                tag,
+                visibility,
+                start,
+                end,
+            )
+            artifacts, total = await orchestrator.store.query_artifacts(
+                filters,
+                limit=limit,
+                offset=offset,
+                embed_meta=embed_meta,
+            )
+            items: list[dict[str, Any]] = []
+            for artifact in artifacts:
+                if isinstance(artifact, ArtifactEnvelope):
+                    items.append(_serialize_artifact(artifact.artifact, artifact.consumptions))
+                else:
+                    items.append(_serialize_artifact(artifact))
+            return {
+                "items": items,
+                "pagination": {"limit": limit, "offset": offset, "total": total},
+            }
+
+        @app.get("/api/v1/artifacts/summary")
+        async def summarize_artifacts(
+            type_names: list[str] | None = Query(None, alias="type"),
+            produced_by: list[str] | None = Query(None),
+            correlation_id: str | None = None,
+            tag: list[str] | None = Query(None),
+            start: str | None = Query(None, alias="from"),
+            end: str | None = Query(None, alias="to"),
+            visibility: list[str] | None = Query(None),
+        ) -> dict[str, Any]:
+            filters = _make_filter_config(
+                type_names,
+                produced_by,
+                correlation_id,
+                tag,
+                visibility,
+                start,
+                end,
+            )
+            summary = await orchestrator.store.summarize_artifacts(filters)
+            return {"summary": summary}
+
         @app.get("/api/v1/artifacts/{artifact_id}")
         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 {
-                "id": str(artifact.id),
-                "type": artifact.type,
-                "payload": artifact.payload,
-                "produced_by": artifact.produced_by,
-                "visibility": artifact.visibility.model_dump(mode="json"),
-                "created_at": artifact.created_at.isoformat(),
-            }
+            return _serialize_artifact(artifact)
 
         @app.post("/api/v1/agents/{name}/run")
         async def run_agent(name: str, body: dict[str, Any]) -> dict[str, Any]:
@@ -110,6 +224,29 @@ class BlackboardHTTPService:
                 ]
             }
 
+        @app.get("/api/v1/agents/{agent_id}/history-summary")
+        async def agent_history(
+            agent_id: str,
+            type_names: list[str] | None = Query(None, alias="type"),
+            produced_by: list[str] | None = Query(None),
+            correlation_id: str | None = None,
+            tag: list[str] | None = Query(None),
+            start: str | None = Query(None, alias="from"),
+            end: str | None = Query(None, alias="to"),
+            visibility: list[str] | None = Query(None),
+        ) -> dict[str, Any]:
+            filters = _make_filter_config(
+                type_names,
+                produced_by,
+                correlation_id,
+                tag,
+                visibility,
+                start,
+                end,
+            )
+            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"}