@eventcatalog/core 3.40.1 → 3.41.0

package/eventcatalog/src/utils/collections/agents.ts

@@ -0,0 +1,163 @@
+import { getCollection } from 'astro:content';
+import type { CollectionEntry } from 'astro:content';
+import type { CollectionMessageTypes } from '@types';
+import { createVersionedMap, findInMap, versionMatches } from '@utils/collections/util';
+import { getChannels } from './channels';
+
+export type Agent = CollectionEntry<'agents'>;
+
+const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
+
+interface Props {
+  getAllVersions?: boolean;
+  returnBody?: boolean;
+}
+
+let memoryCache: Record<string, Agent[]> = {};
+
+export const getAgents = async ({ getAllVersions = true, returnBody = false }: Props = {}): Promise<Agent[]> => {
+  const cacheKey = `${getAllVersions ? 'allVersions' : 'currentVersions'}-${returnBody ? 'withBody' : 'noBody'}`;
+
+  if (memoryCache[cacheKey] && memoryCache[cacheKey].length > 0 && CACHE_ENABLED) {
+    return memoryCache[cacheKey];
+  }
+
+  const [allAgents, allEvents, allCommands, allQueries, allContainers, allFlows] = await Promise.all([
+    getCollection('agents'),
+    getCollection('events'),
+    getCollection('commands'),
+    getCollection('queries'),
+    getCollection('containers'),
+    getCollection('flows'),
+  ]);
+
+  const allMessages = [...allEvents, ...allCommands, ...allQueries];
+  const agentMap = createVersionedMap(allAgents);
+  const messageMap = createVersionedMap(allMessages);
+  const containerMap = createVersionedMap(allContainers);
+  const flowMap = createVersionedMap(allFlows);
+
+  const targetAgents = allAgents.filter((agent) => {
+    if (agent.data.hidden === true) return false;
+    if (!getAllVersions && agent.filePath?.includes('versioned')) return false;
+    return true;
+  });
+
+  const processedAgents = await Promise.all(
+    targetAgents.map(async (agent) => {
+      const agentVersions = agentMap.get(agent.data.id) || [];
+      const latestVersion = agentVersions[0]?.data.version || agent.data.version;
+      const versions = agentVersions.map((a) => a.data.version);
+
+      const sends = (agent.data.sends || [])
+        .map((m) => findInMap(messageMap, m.id, m.version))
+        .filter((e): e is CollectionEntry<CollectionMessageTypes> => !!e);
+
+      const receives = (agent.data.receives || [])
+        .map((m) => findInMap(messageMap, m.id, m.version))
+        .filter((e): e is CollectionEntry<CollectionMessageTypes> => !!e);
+
+      const mappedWritesTo = (agent.data.writesTo || [])
+        .map((c) => findInMap(containerMap, c.id, c.version))
+        .filter((e): e is CollectionEntry<'containers'> => !!e);
+
+      const mappedReadsFrom = (agent.data.readsFrom || [])
+        .map((c) => findInMap(containerMap, c.id, c.version))
+        .filter((e): e is CollectionEntry<'containers'> => !!e);
+
+      const mappedFlows = (agent.data.flows || [])
+        .map((f) => findInMap(flowMap, f.id, f.version))
+        .filter((f): f is CollectionEntry<'flows'> => !!f);
+
+      return {
+        ...agent,
+        data: {
+          ...agent.data,
+          writesTo: mappedWritesTo as any,
+          readsFrom: mappedReadsFrom as any,
+          flows: mappedFlows as any,
+          receives: receives as any,
+          sends: sends as any,
+          versions,
+          latestVersion,
+        },
+        nodes: {
+          receives: receives as any,
+          sends: sends as any,
+        },
+        body: returnBody ? agent.body : undefined,
+      };
+    })
+  );
+
+  processedAgents.sort((a, b) => {
+    return (a.data.name || a.data.id).localeCompare(b.data.name || b.data.id);
+  });
+
+  memoryCache[cacheKey] = processedAgents;
+
+  return processedAgents;
+};
+
+export const getProducersOfMessage = (agents: Agent[], message: CollectionEntry<'events' | 'commands' | 'queries'>) => {
+  return agents.filter((agent) => {
+    return agent.data.sends?.some((send) => {
+      const idMatch = send.id === message.data.id;
+      if (!send.version) return idMatch;
+      if (send.version === 'latest') return idMatch;
+      return idMatch && versionMatches(message.data.version, send.version);
+    });
+  });
+};
+
+export const getConsumersOfMessage = (agents: Agent[], message: CollectionEntry<'events' | 'commands' | 'queries'>) => {
+  return agents.filter((agent) => {
+    return agent.data.receives?.some((receive) => {
+      const idMatch = receive.id === message.data.id;
+      if (!receive.version) return idMatch;
+      if (receive.version === 'latest') return idMatch;
+      return idMatch && versionMatches(message.data.version, receive.version);
+    });
+  });
+};
+
+export const getChannelsForAgent = async (agentId: string, version?: string): Promise<CollectionEntry<'channels'>[]> => {
+  const allAgents = await getCollection('agents');
+  const allChannels = await getChannels({ getAllVersions: true });
+
+  const agentMap = createVersionedMap(allAgents);
+  const agent = findInMap(agentMap, agentId, version);
+  if (!agent) return [];
+
+  const sends = agent.data.sends ?? [];
+  const receives = agent.data.receives ?? [];
+
+  const channelPointers: Array<{ id: string; version?: string }> = [];
+
+  for (const send of sends) {
+    for (const channel of send.to ?? []) {
+      channelPointers.push({ id: channel.id, version: channel.version });
+    }
+  }
+
+  for (const receive of receives) {
+    for (const channel of receive.from ?? []) {
+      channelPointers.push({ id: channel.id, version: channel.version });
+    }
+  }
+
+  const channelMap = createVersionedMap(allChannels);
+  const seen = new Set<string>();
+  const channels: CollectionEntry<'channels'>[] = [];
+
+  for (const pointer of channelPointers) {
+    const key = `${pointer.id}-${pointer.version ?? 'latest'}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+
+    const match = findInMap(channelMap, pointer.id, pointer.version);
+    if (match) channels.push(match as CollectionEntry<'channels'>);
+  }
+
+  return channels;
+};

package/eventcatalog/src/utils/collections/commands.ts

@@ -26,8 +26,9 @@ export const getCommands = async ({ getAllVersions = true, hydrateServices = tru
   }
 
   // 1. Fetch collections in parallel
-  const [allCommands, allServices, allChannels, allDataProducts] = await Promise.all([
+  const [allCommands, allAgents, allServices, allChannels, allDataProducts] = await Promise.all([
     getCollection('commands'),
+    getCollection('agents'),
     getCollection('services'),
     getCollection('channels'),
     getCollection('data-products'),
@@ -35,7 +36,7 @@ export const getCommands = async ({ getAllVersions = true, hydrateServices = tru
 
   // 2. Build optimized maps
   const commandMap = createVersionedMap(allCommands);
-  const pcIndex = buildProducerConsumerIndex(allServices, allDataProducts);
+  const pcIndex = buildProducerConsumerIndex(allAgents, allServices, allDataProducts);
 
   // Build channel lookup map: channelId → channel entries
   const channelById = new Map<string, typeof allChannels>();

package/eventcatalog/src/utils/collections/domains.ts

@@ -2,7 +2,7 @@ import { getCollection } from 'astro:content';
 import type { CollectionEntry } from 'astro:content';
 import path from 'path';
 import type { CollectionMessageTypes } from '@types';
-import type { Service } from './types';
+import type { Agent, Service } from './types';
 import { createVersionedMap, findInMap, processSpecifications } from '@utils/collections/util';
 
 const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
@@ -60,6 +60,45 @@ const hydrateServices = (
     });
 };
 
+const hydrateAgents = (
+  agentsList: any[],
+  agentMap: Map<string, any[]>,
+  messageMap: Map<string, any[]>,
+  containerMap: Map<string, any[]>
+) => {
+  return agentsList
+    .map((agent: { id: string; version: string | undefined }) => findInMap(agentMap, agent.id, agent.version))
+    .filter((a) => !!a)
+    .map((agent) => {
+      const sends = (agent.data.sends || [])
+        .map((msg: any) => findInMap(messageMap, msg.id, msg.version))
+        .filter((m: any) => !!m);
+
+      const receives = (agent.data.receives || [])
+        .map((msg: any) => findInMap(messageMap, msg.id, msg.version))
+        .filter((m: any) => !!m);
+
+      const readsFrom = (agent.data.readsFrom || [])
+        .map((c: any) => findInMap(containerMap, c.id, c.version))
+        .filter((c: any) => !!c);
+
+      const writesTo = (agent.data.writesTo || [])
+        .map((c: any) => findInMap(containerMap, c.id, c.version))
+        .filter((c: any) => !!c);
+
+      return {
+        ...agent,
+        data: {
+          ...agent.data,
+          sends: sends as any,
+          receives: receives as any,
+          readsFrom: readsFrom as any,
+          writesTo: writesTo as any,
+        },
+      };
+    });
+};
+
 // --- MAIN FUNCTION ---
 
 export const getDomains = async ({
@@ -78,18 +117,29 @@ export const getDomains = async ({
   }
 
   // 1. Fetch collections (always fetch messages to hydrate domain-level sends/receives)
-  const [allDomains, allServices, allEntities, allFlows, allEvents, allCommands, allQueries, allContainers, allDataProducts] =
-    await Promise.all([
-      getCollection('domains'),
-      getCollection('services'),
-      getCollection('entities'),
-      getCollection('flows'),
-      getCollection('events'),
-      getCollection('commands'),
-      getCollection('queries'),
-      getCollection('containers'),
-      getCollection('data-products'),
-    ]);
+  const [
+    allDomains,
+    allAgents,
+    allServices,
+    allEntities,
+    allFlows,
+    allEvents,
+    allCommands,
+    allQueries,
+    allContainers,
+    allDataProducts,
+  ] = await Promise.all([
+    getCollection('domains'),
+    getCollection('agents'),
+    getCollection('services'),
+    getCollection('entities'),
+    getCollection('flows'),
+    getCollection('events'),
+    getCollection('commands'),
+    getCollection('queries'),
+    getCollection('containers'),
+    getCollection('data-products'),
+  ]);
 
   const allMessages = [...allEvents, ...allCommands, ...allQueries];
   const messageMap = createVersionedMap(allMessages);
@@ -97,6 +147,7 @@ export const getDomains = async ({
 
   // 2. Build optimized maps
   const domainMap = createVersionedMap(allDomains);
+  const agentMap = createVersionedMap(allAgents);
   const serviceMap = createVersionedMap(allServices);
   const entityMap = createVersionedMap(allEntities);
   const flowMap = createVersionedMap(allFlows);
@@ -127,13 +178,18 @@ export const getDomains = async ({
         .map((subDomain: any) => {
           // Hydrate services for the subdomain
           let hydratedServices = subDomain.data.services || [];
+          let hydratedAgents = subDomain.data.agents || [];
           if (enrichServices) {
             hydratedServices = hydrateServices(subDomain.data.services || [], serviceMap, messageMap, containerMap);
+            hydratedAgents = hydrateAgents(subDomain.data.agents || [], agentMap, messageMap, containerMap);
           } else {
             // Just resolve the service objects without enrichment
             hydratedServices = (subDomain.data.services || [])
               .map((service: { id: string; version: string | undefined }) => findInMap(serviceMap, service.id, service.version))
               .filter((s: any) => !!s);
+            hydratedAgents = (subDomain.data.agents || [])
+              .map((agent: { id: string; version: string | undefined }) => findInMap(agentMap, agent.id, agent.version))
+              .filter((a: any) => !!a);
           }
 
           // Hydrate data products for the subdomain
@@ -146,6 +202,7 @@ export const getDomains = async ({
             data: {
               ...subDomain.data,
               services: hydratedServices as any,
+              agents: hydratedAgents as any,
               'data-products': subdomainDataProducts as any,
             },
           };
@@ -173,23 +230,33 @@ export const getDomains = async ({
 
       // Resolve Services for Main Domain
       const servicesInDomain = domain.data.services || [];
+      const agentsInDomain = domain.data.agents || [];
 
       // Hydrate main domain services
       let hydratedMainServices = [];
+      let hydratedMainAgents = [];
       if (enrichServices) {
         hydratedMainServices = hydrateServices(servicesInDomain, serviceMap, messageMap, containerMap);
+        hydratedMainAgents = hydrateAgents(agentsInDomain, agentMap, messageMap, containerMap);
       } else {
         hydratedMainServices = servicesInDomain
           .map((service: { id: string; version: string | undefined }) => findInMap(serviceMap, service.id, service.version))
           .filter((s) => !!s);
+        hydratedMainAgents = agentsInDomain
+          .map((agent: { id: string; version: string | undefined }) => findInMap(agentMap, agent.id, agent.version))
+          .filter((a) => !!a);
       }
 
       // Get already-hydrated subdomain services
       const hydratedSubdomainServices = subDomains.flatMap((subDomain: any) => subDomain.data.services || []);
+      const hydratedSubdomainAgents = subDomains.flatMap((subDomain: any) => subDomain.data.agents || []);
 
       const services = includeServicesInSubdomains
         ? [...(hydratedMainServices as any), ...(hydratedSubdomainServices as any)]
         : (hydratedMainServices as any);
+      const agents = includeServicesInSubdomains
+        ? [...(hydratedMainAgents as any), ...(hydratedSubdomainAgents as any)]
+        : (hydratedMainAgents as any);
 
       // Hydrate domain-level sends and receives
       const domainSends = (domain.data.sends || [])
@@ -204,6 +271,7 @@ export const getDomains = async ({
         ...domain,
         data: {
           ...domain.data,
+          agents: agents as any,
           services: services as any, // Cast to avoid deep type issues with enriched data
           domains: subDomains as any,
           entities: entities as any,
@@ -236,6 +304,7 @@ export const getMessagesForDomain = async (
 ): Promise<{ sends: CollectionEntry<CollectionMessageTypes>[]; receives: CollectionEntry<CollectionMessageTypes>[] }> => {
   // We already have the services from the domain
   const services = domain.data.services as unknown as CollectionEntry<'services'>[];
+  const agents = ((domain.data.agents as unknown as CollectionEntry<'agents'>[]) || []) as CollectionEntry<'agents'>[];
 
   const [events, commands, queries] = await Promise.all([
     getCollection('events'),
@@ -249,14 +318,16 @@ export const getMessagesForDomain = async (
   // Get service-level sends/receives
   const serviceSends = services.flatMap((service) => service.data.sends || []);
   const serviceReceives = services.flatMap((service) => service.data.receives || []);
+  const agentSends = agents.flatMap((agent) => agent.data.sends || []);
+  const agentReceives = agents.flatMap((agent) => agent.data.receives || []);
 
   // Get domain-level sends/receives (already hydrated if domain came from getDomains)
   const domainSends = domain.data.sends || [];
   const domainReceives = domain.data.receives || [];
 
   // Combine and deduplicate - domain-level messages take priority
-  const allSends = [...domainSends, ...serviceSends];
-  const allReceives = [...domainReceives, ...serviceReceives];
+  const allSends = [...domainSends, ...serviceSends, ...agentSends];
+  const allReceives = [...domainReceives, ...serviceReceives, ...agentReceives];
 
   const sendsMessages = allSends
     .map((send: any) => {
@@ -380,6 +451,14 @@ export const getDomainsForService = async (service: Service): Promise<Domain[]>
   });
 };
 
+export const getDomainsForAgent = async (agent: Agent): Promise<Domain[]> => {
+  const domains = await getDomains({ getAllVersions: false });
+  return domains.filter((d) => {
+    const agents = ((d.data.agents as unknown as Agent[]) || []) as Agent[];
+    return agents.some((a) => a.data.id === agent.data.id);
+  });
+};
+
 export const domainHasEntities = (domain: Domain): boolean => {
   return (domain.data.entities && domain.data.entities.length > 0) || false;
 };

package/eventcatalog/src/utils/collections/events.ts

@@ -26,8 +26,9 @@ export const getEvents = async ({ getAllVersions = true, hydrateServices = true
   }
 
   // 1. Fetch collections in parallel
-  const [allEvents, allServices, allChannels, allDataProducts] = await Promise.all([
+  const [allEvents, allAgents, allServices, allChannels, allDataProducts] = await Promise.all([
     getCollection('events'),
+    getCollection('agents'),
     getCollection('services'),
     getCollection('channels'),
     getCollection('data-products'),
@@ -35,7 +36,7 @@ export const getEvents = async ({ getAllVersions = true, hydrateServices = true
 
   // 2. Build optimized maps
   const eventMap = createVersionedMap(allEvents);
-  const pcIndex = buildProducerConsumerIndex(allServices, allDataProducts);
+  const pcIndex = buildProducerConsumerIndex(allAgents, allServices, allDataProducts);
 
   // Build channel lookup map: channelId → channel entries
   const channelById = new Map<string, typeof allChannels>();

package/eventcatalog/src/utils/collections/flows.ts

@@ -3,6 +3,7 @@ import type { CollectionEntry } from 'astro:content';
 import { createVersionedMap, findInMap } from '@utils/collections/util';
 import { getDomains } from './domains';
 import { getServices } from './services';
+import { getAgents } from './agents';
 
 const CACHE_ENABLED = process.env.DISABLE_EVENTCATALOG_CACHE !== 'true';
 export type Flow = CollectionEntry<'flows'>;
@@ -24,11 +25,12 @@ export const getFlows = async ({ getAllVersions = true }: Props = {}): Promise<F
   }
 
   // 1. Fetch collections in parallel
-  const [allFlows, allEvents, allCommands, allQueries, allContainers, allDataProducts] = await Promise.all([
+  const [allFlows, allEvents, allCommands, allQueries, allAgents, allContainers, allDataProducts] = await Promise.all([
     getCollection('flows'),
     getCollection('events'),
     getCollection('commands'),
     getCollection('queries'),
+    getCollection('agents'),
     getCollection('containers'),
     getCollection('data-products'),
   ]);
@@ -38,6 +40,7 @@ export const getFlows = async ({ getAllVersions = true }: Props = {}): Promise<F
   // 2. Build optimized maps
   const flowMap = createVersionedMap(allFlows);
   const messageMap = createVersionedMap(allMessages);
+  const agentMap = createVersionedMap(allAgents);
   const containerMap = createVersionedMap(allContainers);
   const dataProductMap = createVersionedMap(allDataProducts);
 
@@ -82,6 +85,18 @@ export const getFlows = async ({ getAllVersions = true }: Props = {}): Promise<F
         };
       }
 
+      if (step.agent) {
+        const pointer = step.agent;
+        if (!pointer) return { ...step, type: 'node' };
+        const agent = findInMap(agentMap, pointer.id, pointer.version);
+
+        return {
+          ...step,
+          type: 'agents',
+          agent: agent ? [agent] : [],
+        };
+      }
+
       if (!step.message) return { ...step, type: 'node' }; // Preserve existing step data for non-messages
 
       const message = findInMap(messageMap, step.message.id, step.message.version);
@@ -116,16 +131,18 @@ export const getFlows = async ({ getAllVersions = true }: Props = {}): Promise<F
 };
 
 export const getFlowsNotInAnyResource = async (): Promise<Flow[]> => {
-  const [flows, domains, services] = await Promise.all([
+  const [flows, domains, services, agents] = await Promise.all([
     getFlows({ getAllVersions: false }),
     getDomains({ getAllVersions: false }),
     getServices({ getAllVersions: false }),
+    getAgents({ getAllVersions: false }),
   ]);
 
   const flowsNotInAnyResource = flows.filter((flow) => {
     const domainsForFlow = domains.filter((domain) => domain.data.flows?.some((f: any) => f.id === flow.id));
     const servicesForFlow = services.filter((service) => service.data.flows?.some((f: any) => f.id === flow.id));
-    return domainsForFlow.length === 0 && servicesForFlow.length === 0;
+    const agentsForFlow = agents.filter((agent) => agent.data.flows?.some((f: any) => f.id === flow.id));
+    return domainsForFlow.length === 0 && servicesForFlow.length === 0 && agentsForFlow.length === 0;
   });
   return flowsNotInAnyResource;
 };

package/eventcatalog/src/utils/collections/icons.ts

@@ -12,13 +12,15 @@ import {
   MapIcon,
   CubeIcon,
 } from '@heroicons/react/24/outline';
-import { BookText, Box, DatabaseIcon } from 'lucide-react';
+import { BookText, Bot, Box, DatabaseIcon } from 'lucide-react';
 import { getColorForCollection } from '@utils/collection-colors';
 
 export const getIconForCollection = (collection: string) => {
   switch (collection) {
     case 'domains':
       return RectangleGroupIcon;
+    case 'agents':
+      return Bot;
     case 'services':
       return ServerIcon;
     case 'events':

package/eventcatalog/src/utils/collections/messages.ts

@@ -20,6 +20,7 @@ interface HydrateProducersAndConsumersProps {
       latestVersion?: string;
     };
   };
+  agents?: CollectionEntry<'agents'>[];
   services: CollectionEntry<'services'>[];
   dataProducts: CollectionEntry<'data-products'>[];
   hydrate?: boolean;
@@ -31,6 +32,7 @@ interface HydrateProducersAndConsumersProps {
  */
 export const hydrateProducersAndConsumers = ({
   message,
+  agents = [],
   services = [],
   dataProducts = [],
   hydrate = true,
@@ -44,11 +46,23 @@ export const hydrateProducersAndConsumers = ({
     return satisfies(messageVersion, pointerVersion);
   };
 
-  const toResult = <T extends CollectionEntry<'services'> | CollectionEntry<'data-products'>>(resource: T) => {
+  const toResult = <T extends CollectionEntry<'agents'> | CollectionEntry<'services'> | CollectionEntry<'data-products'>>(
+    resource: T
+  ) => {
     if (!hydrate) return { id: resource.data.id, version: resource.data.version };
     return resource;
   };
 
+  // Agents that send this message (producers)
+  const agentProducers = agents
+    .filter((a) => a.data.sends?.some((p) => p.id === messageId && matchesVersion(p.version)))
+    .map(toResult);
+
+  // Agents that receive this message (consumers)
+  const agentConsumers = agents
+    .filter((a) => a.data.receives?.some((p) => p.id === messageId && matchesVersion(p.version)))
+    .map(toResult);
+
   // Services that send this message (producers)
   const serviceProducers = services
     .filter((s) => s.data.sends?.some((p) => p.id === messageId && matchesVersion(p.version)))
@@ -70,15 +84,15 @@ export const hydrateProducersAndConsumers = ({
     .map(toResult);
 
   return {
-    producers: [...serviceProducers, ...dataProductProducers],
-    consumers: [...serviceConsumers, ...dataProductConsumers],
+    producers: [...agentProducers, ...serviceProducers, ...dataProductProducers],
+    consumers: [...agentConsumers, ...serviceConsumers, ...dataProductConsumers],
   };
 };
 
 // --- Reverse Index for O(1) producer/consumer lookups ---
 
 interface IndexEntry {
-  resource: CollectionEntry<'services'> | CollectionEntry<'data-products'>;
+  resource: CollectionEntry<'agents'> | CollectionEntry<'services'> | CollectionEntry<'data-products'>;
   pointerVersion?: string;
 }
 
@@ -92,6 +106,7 @@ export interface ProducerConsumerIndex {
  * Call once before the enrichment loop, then use lookupProducersAndConsumers per message.
  */
 export const buildProducerConsumerIndex = (
+  agents: CollectionEntry<'agents'>[],
   services: CollectionEntry<'services'>[],
   dataProducts: CollectionEntry<'data-products'>[]
 ): ProducerConsumerIndex => {
@@ -107,6 +122,19 @@ export const buildProducerConsumerIndex = (
     list.push(entry);
   };
 
+  for (const agent of agents || []) {
+    if (agent.data.sends) {
+      for (const p of agent.data.sends) {
+        addEntry(producers, p.id, { resource: agent, pointerVersion: p.version });
+      }
+    }
+    if (agent.data.receives) {
+      for (const p of agent.data.receives) {
+        addEntry(consumers, p.id, { resource: agent, pointerVersion: p.version });
+      }
+    }
+  }
+
   for (const service of services || []) {
     if (service.data.sends) {
       for (const p of service.data.sends) {
@@ -162,7 +190,9 @@ export const lookupProducersAndConsumers = ({ message, index, hydrate = true }:
     return satisfies(messageVersion, pointerVersion);
   };
 
-  const toResult = <T extends CollectionEntry<'services'> | CollectionEntry<'data-products'>>(resource: T) => {
+  const toResult = <T extends CollectionEntry<'agents'> | CollectionEntry<'services'> | CollectionEntry<'data-products'>>(
+    resource: T
+  ) => {
     if (!hydrate) return { id: resource.data.id, version: resource.data.version };
     return resource;
   };

package/eventcatalog/src/utils/collections/queries.ts

@@ -25,8 +25,9 @@ export const getQueries = async ({ getAllVersions = true, hydrateServices = true
   }
 
   // 1. Fetch collections in parallel
-  const [allQueries, allServices, allChannels, allDataProducts] = await Promise.all([
+  const [allQueries, allAgents, allServices, allChannels, allDataProducts] = await Promise.all([
     getCollection('queries'),
+    getCollection('agents'),
     getCollection('services'),
     getCollection('channels'),
     getCollection('data-products'),
@@ -34,7 +35,7 @@ export const getQueries = async ({ getAllVersions = true, hydrateServices = true
 
   // 2. Build optimized maps
   const queryMap = createVersionedMap(allQueries);
-  const pcIndex = buildProducerConsumerIndex(allServices, allDataProducts);
+  const pcIndex = buildProducerConsumerIndex(allAgents, allServices, allDataProducts);
 
   // Build channel lookup map: channelId → channel entries
   const channelById = new Map<string, typeof allChannels>();

package/eventcatalog/src/utils/collections/schemas.ts

@@ -10,13 +10,13 @@ export type Schema = {
   format: string;
 };
 
-const getPublicPath = (resource: CollectionEntry<PageTypes>): string | undefined => {
+const getPublicPath = (resource: CollectionEntry<PageTypes> | any): string | undefined => {
   if (!resource.filePath) return undefined;
   const folderName = getFolderNameFromFilePath(resource.filePath);
   return path.join('/generated', resource.collection, folderName);
 };
 
-export const getSchemaURL = (resource: CollectionEntry<PageTypes>) => {
+export const getSchemaURL = (resource: CollectionEntry<PageTypes> | any) => {
   const publicPath = getPublicPath(resource);
   const schemaFilePath = resource?.data?.schemaPath;
 
@@ -45,7 +45,7 @@ export const getSchemaFormatFromURL = (url: string) => {
   return format;
 };
 
-export const getSchemasFromResource = (resource: CollectionEntry<PageTypes>): Schema[] => {
+export const getSchemasFromResource = (resource: CollectionEntry<PageTypes> | any): Schema[] => {
   const schemaPublicPath = getSchemaURL(resource);
 
   if (!schemaPublicPath) {
@@ -53,7 +53,7 @@ export const getSchemasFromResource = (resource: CollectionEntry<PageTypes>): Sc
   }
 
   if (resource.collection === 'services') {
-    const specifications = resource?.data?.specifications;
+    const specifications = (resource?.data as any)?.specifications;
     const asyncapiPath = Array.isArray(specifications)
       ? specifications.find((spec) => spec.type === 'asyncapi')?.path
       : specifications?.asyncapiPath;

package/eventcatalog/src/utils/collections/services.ts

@@ -161,7 +161,7 @@ export const getConsumersOfMessage = (services: Service[], message: CollectionEn
 };
 
 export const getSpecificationsForService = (service: CollectionEntry<CollectionTypes>) => {
-  return processSpecifications(service.data.specifications as any);
+  return processSpecifications((service.data as any).specifications as any);
 };
 // Get services for channel
 export const getProducersAndConsumersForChannel = async (channel: CollectionEntry<'channels'>) => {