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

flock/frontend/src/store/graphStore.ts

@@ -76,14 +76,79 @@ function toDashboardState(
   consumptions: Map<string, string[]>
 ): DashboardState {
   const artifacts = new Map<string, Artifact>();
+  const syntheticRuns = new Map(runs);
+
+  const producedBuckets = new Map<string, Set<string>>();
+  const consumedBuckets = new Map<string, Set<string>>();
+
+  // Helper to build bucket keys based on agent + correlation
+  const makeBucketKey = (agentId: string, correlationId: string) =>
+    `${agentId}::${correlationId || 'uncorrelated'}`;
+
+  // Track (agent, correlation) pairs that already have explicit run data
+  const existingRunBuckets = new Set<string>();
+  runs.forEach((run) => {
+    existingRunBuckets.add(makeBucketKey(run.agent_name, run.correlation_id));
+  });
 
   messages.forEach((message) => {
     artifacts.set(message.id, messageToArtifact(message, consumptions));
+
+    if (message.producedBy) {
+      const key = makeBucketKey(message.producedBy, message.correlationId);
+      if (!producedBuckets.has(key)) {
+        producedBuckets.set(key, new Set());
+      }
+      producedBuckets.get(key)!.add(message.id);
+    }
+  });
+
+  consumptions.forEach((consumerIds, artifactId) => {
+    const message = messages.get(artifactId);
+    const correlationId = message?.correlationId ?? '';
+    consumerIds.forEach((consumerId) => {
+      const key = makeBucketKey(consumerId, correlationId);
+      if (!consumedBuckets.has(key)) {
+        consumedBuckets.set(key, new Set());
+      }
+      consumedBuckets.get(key)!.add(artifactId);
+    });
+  });
+
+  let syntheticCounter = 0;
+  consumedBuckets.forEach((consumedSet, key) => {
+    if (consumedSet.size === 0) {
+      return;
+    }
+    const producedSet = producedBuckets.get(key);
+    if (!producedSet || producedSet.size === 0) {
+      return;
+    }
+
+    if (existingRunBuckets.has(key)) {
+      return;
+    }
+
+    const [agentIdRaw, correlationPartRaw] = key.split('::');
+    const agentId = agentIdRaw || 'unknown-agent';
+    const correlationPart = correlationPartRaw || 'uncorrelated';
+    const runId = `historic_${agentId}_${correlationPart}_${syntheticCounter++}`;
+
+    if (!syntheticRuns.has(runId)) {
+      syntheticRuns.set(runId, {
+        run_id: runId,
+        agent_name: agentId,
+        correlation_id: correlationPart === 'uncorrelated' ? '' : correlationPart,
+        status: 'completed',
+        consumed_artifacts: Array.from(consumedSet),
+        produced_artifacts: Array.from(producedSet),
+      });
+    }
   });
 
   return {
     artifacts,
-    runs,
+    runs: syntheticRuns,
     consumptions, // Phase 11: Pass actual consumption data for filtered count calculation
   };
 }
@@ -251,6 +316,8 @@ export const useGraphStore = create<GraphState>()(
         const edges = deriveAgentViewEdges(dashboardState);
 
         set({ nodes, edges });
+        // Re-apply active filters so newly generated nodes respect current selections
+        useGraphStore.getState().applyFilters();
       },
 
       generateBlackboardViewGraph: () => {
@@ -289,6 +356,8 @@ export const useGraphStore = create<GraphState>()(
               timestamp: message.timestamp,
               isStreaming: message.isStreaming || false,
               streamingText: message.streamingText || '',
+              tags: message.tags || [],
+              visibilityKind: message.visibilityKind || 'Unknown',
             },
           });
         });
@@ -298,6 +367,8 @@ export const useGraphStore = create<GraphState>()(
         const edges = deriveBlackboardViewEdges(dashboardState);
 
         set({ nodes, edges });
+        // Ensure filters are reapplied after regeneration
+        useGraphStore.getState().applyFilters();
       },
 
       batchUpdate: (update) =>
@@ -312,9 +383,16 @@ export const useGraphStore = create<GraphState>()(
 
           if (update.messages) {
             const messages = new Map(state.messages);
-            update.messages.forEach((m) => messages.set(m.id, m));
+            const consumptions = new Map(state.consumptions);
+            update.messages.forEach((m) => {
+              messages.set(m.id, m);
+              if (m.consumedBy && m.consumedBy.length > 0) {
+                consumptions.set(m.id, Array.from(new Set(m.consumedBy)));
+              }
+            });
             newState.messages = messages;
             newState.events = [...update.messages, ...state.events].slice(0, 100);
+            newState.consumptions = consumptions;
           }
 
           if (update.runs) {
@@ -327,8 +405,15 @@ export const useGraphStore = create<GraphState>()(
         }),
 
       applyFilters: () => {
-        const { nodes, edges, messages } = get();
-        const { correlationId, timeRange } = useFilterStore.getState();
+        const { nodes, edges, messages, consumptions } = get();
+        const {
+          correlationId,
+          timeRange,
+          selectedArtifactTypes,
+          selectedProducers,
+          selectedTags,
+          selectedVisibility,
+        } = useFilterStore.getState();
 
         // Helper to calculate time range boundaries
         const getTimeRangeBoundaries = (): { start: number; end: number } => {
@@ -342,64 +427,118 @@ export const useGraphStore = create<GraphState>()(
           } else if (timeRange.preset === 'custom' && timeRange.start && timeRange.end) {
             return { start: timeRange.start, end: timeRange.end };
           }
-          return { start: now - 10 * 60 * 1000, end: now };
+          return { start: Number.NEGATIVE_INFINITY, end: Number.POSITIVE_INFINITY };
         };
 
         const { start: timeStart, end: timeEnd } = getTimeRangeBoundaries();
 
-        // Filter messages based on correlation ID and time range
         const visibleMessageIds = new Set<string>();
+        const producedStats = new Map<string, { total: number; byType: Record<string, number> }>();
+        const consumedStats = new Map<string, { total: number; byType: Record<string, number> }>();
+
+        const incrementStat = (
+          map: Map<string, { total: number; byType: Record<string, number> }>,
+          key: string,
+          type: string
+        ) => {
+          if (!map.has(key)) {
+            map.set(key, { total: 0, byType: {} });
+          }
+          const entry = map.get(key)!;
+          entry.total += 1;
+          entry.byType[type] = (entry.byType[type] || 0) + 1;
+        };
+
         messages.forEach((message) => {
           let visible = true;
 
-          // Apply correlation ID filter (selective)
           if (correlationId && message.correlationId !== correlationId) {
             visible = false;
           }
 
-          // Apply time range filter (in-memory)
           if (visible && (message.timestamp < timeStart || message.timestamp > timeEnd)) {
             visible = false;
           }
 
+          if (
+            visible &&
+            selectedArtifactTypes.length > 0 &&
+            !selectedArtifactTypes.includes(message.type)
+          ) {
+            visible = false;
+          }
+
+          if (
+            visible &&
+            selectedProducers.length > 0 &&
+            !selectedProducers.includes(message.producedBy)
+          ) {
+            visible = false;
+          }
+
+          if (
+            visible &&
+            selectedVisibility.length > 0 &&
+            !selectedVisibility.includes(message.visibilityKind || 'Unknown')
+          ) {
+            visible = false;
+          }
+
+          if (visible && selectedTags.length > 0) {
+            const messageTags = message.tags || [];
+            const hasAllTags = selectedTags.every((tag) => messageTags.includes(tag));
+            if (!hasAllTags) {
+              visible = false;
+            }
+          }
+
           if (visible) {
             visibleMessageIds.add(message.id);
+            incrementStat(producedStats, message.producedBy, message.type);
+
+            const consumers = consumptions.get(message.id) || [];
+            consumers.forEach((consumerId) => {
+              incrementStat(consumedStats, consumerId, message.type);
+            });
           }
         });
 
-        // Update nodes visibility
         const updatedNodes = nodes.map((node) => {
           if (node.type === 'message') {
-            // For message nodes, check if message is visible
             return {
               ...node,
               hidden: !visibleMessageIds.has(node.id),
             };
-          } else if (node.type === 'agent') {
-            // For agent nodes, show if any visible messages involve this agent
-            let hasVisibleMessages = false;
-            messages.forEach((message) => {
-              if (visibleMessageIds.has(message.id)) {
-                if (message.producedBy === node.id) {
-                  hasVisibleMessages = true;
-                }
-              }
-            });
+          }
+          if (node.type === 'agent') {
+            const produced = producedStats.get(node.id);
+            const consumed = consumedStats.get(node.id);
+            const currentData = node.data as AgentNodeData;
             return {
               ...node,
-              hidden: !hasVisibleMessages,
+              hidden: false,
+              data: {
+                ...node.data,
+                sentCount: produced?.total ?? currentData.sentCount ?? 0,
+                recvCount: consumed?.total ?? currentData.recvCount ?? 0,
+                sentByType: produced?.byType ?? currentData.sentByType ?? {},
+                receivedByType: consumed?.byType ?? currentData.receivedByType ?? {},
+              },
             };
           }
           return node;
         });
 
-        // Update edges visibility
         const updatedEdges = edges.map((edge) => {
-          // Hide edge if either source or target node is hidden
-          const sourceNode = updatedNodes.find((n) => n.id === edge.source);
-          const targetNode = updatedNodes.find((n) => n.id === edge.target);
-          const hidden = sourceNode?.hidden || targetNode?.hidden || false;
-
+          let hidden = edge.hidden ?? false;
+          const data: any = edge.data;
+          if (data && Array.isArray(data.artifactIds) && data.artifactIds.length > 0) {
+            hidden = data.artifactIds.every((artifactId: string) => !visibleMessageIds.has(artifactId));
+          } else {
+            const sourceNode = updatedNodes.find((n) => n.id === edge.source);
+            const targetNode = updatedNodes.find((n) => n.id === edge.target);
+            hidden = !!(sourceNode?.hidden || targetNode?.hidden);
+          }
           return {
             ...edge,
             hidden,

flock/frontend/src/types/filters.ts

@@ -1,4 +1,4 @@
-export type TimeRangePreset = 'last5min' | 'last10min' | 'last1hour' | 'custom';
+export type TimeRangePreset = 'last5min' | 'last10min' | 'last1hour' | 'custom' | 'all';
 
 export interface TimeRange {
   preset: TimeRangePreset;
@@ -12,3 +12,36 @@ export interface CorrelationIdMetadata {
   artifact_count: number;
   run_count: number;
 }
+
+export interface FilterFacets {
+  artifactTypes: string[];
+  producers: string[];
+  tags: string[];
+  visibilities: string[];
+}
+
+export interface ArtifactSummary {
+  total: number;
+  by_type: Record<string, number>;
+  by_producer: Record<string, number>;
+  by_visibility: Record<string, number>;
+  tag_counts: Record<string, number>;
+  earliest_created_at: string | null;
+  latest_created_at: string | null;
+}
+
+export interface FilterSnapshot {
+  correlationId: string | null;
+  timeRange: TimeRange;
+  artifactTypes: string[];
+  producers: string[];
+  tags: string[];
+  visibility: string[];
+}
+
+export interface SavedFilterMeta {
+  filter_id: string;
+  name: string;
+  created_at: number;
+  filters: FilterSnapshot;
+}

flock/frontend/src/types/graph.ts

@@ -22,8 +22,13 @@ export interface Message {
   timestamp: number;
   correlationId: string;
   producedBy: string;
+  tags?: string[];
+  visibilityKind?: string;
+  partitionKey?: string | null;
+  version?: number;
   isStreaming?: boolean; // True while streaming, false when complete
   streamingText?: string; // Accumulated streaming text (raw)
+  consumedBy?: string[];
 }
 
 export interface AgentNodeData extends Record<string, unknown> {
@@ -47,6 +52,8 @@ export interface MessageNodeData extends Record<string, unknown> {
   timestamp: number;
   isStreaming?: boolean; // True while streaming tokens
   streamingText?: string; // Raw streaming text
+  tags?: string[];
+  visibilityKind?: string;
 }
 
 export type AgentViewNode = Node<AgentNodeData, 'agent'>;

flock/frontend/src/utils/artifacts.ts

@@ -0,0 +1,24 @@
+import type { ArtifactListItem } from '../services/api';
+import type { Message } from '../types/graph';
+
+export function mapArtifactToMessage(item: ArtifactListItem): Message {
+  const consumedBy =
+    item.consumed_by ??
+    (item.consumptions ? Array.from(new Set(item.consumptions.map((record) => record.consumer))) : []);
+
+  return {
+    id: item.id,
+    type: item.type,
+    payload: item.payload,
+    timestamp: new Date(item.created_at).getTime(),
+    correlationId: item.correlation_id ?? '',
+    producedBy: item.produced_by,
+    tags: item.tags || [],
+    visibilityKind: item.visibility_kind || item.visibility?.kind || 'Unknown',
+    partitionKey: item.partition_key ?? null,
+    version: item.version ?? 1,
+    isStreaming: false,
+    streamingText: '',
+    consumedBy,
+  };
+}

flock/orchestrator.py

@@ -3,10 +3,12 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 import os
 from asyncio import Task
 from collections.abc import Iterable, Mapping, Sequence
 from contextlib import asynccontextmanager
+from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any, AsyncGenerator
 from uuid import uuid4
 
@@ -27,7 +29,7 @@ from flock.mcp import (
 )
 from flock.registry import type_registry
 from flock.runtime import Context
-from flock.store import BlackboardStore, InMemoryBlackboardStore
+from flock.store import BlackboardStore, ConsumptionRecord, InMemoryBlackboardStore
 from flock.visibility import AgentIdentity, PublicVisibility, Visibility
 
 
@@ -110,6 +112,7 @@ class Flock(metaclass=AutoTracedMeta):
             ... )
         """
         self._patch_litellm_proxy_imports()
+        self._logger = logging.getLogger(__name__)
         self.model = model
         self.store: BlackboardStore = store or InMemoryBlackboardStore()
         self._agents: dict[str, Agent] = {}
@@ -891,6 +894,25 @@ class Flock(metaclass=AutoTracedMeta):
         self._record_agent_run(agent)
         await agent.execute(ctx, artifacts)
 
+        if artifacts:
+            try:
+                timestamp = datetime.now(timezone.utc)
+                records = [
+                    ConsumptionRecord(
+                        artifact_id=artifact.id,
+                        consumer=agent.name,
+                        run_id=ctx.task_id,
+                        correlation_id=str(correlation_id) if correlation_id else None,
+                        consumed_at=timestamp,
+                    )
+                    for artifact in artifacts
+                ]
+                await self.store.record_consumptions(records)
+            except NotImplementedError:
+                pass
+            except Exception as exc:  # pragma: no cover - defensive logging
+                self._logger.exception("Failed to record artifact consumption: %s", exc)
+
     # Helpers --------------------------------------------------------------
 
     def _normalize_input(

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"}