@eventcatalog/core 5.7.4 → 5.7.5

package/eventcatalog/src/utils/node-graphs/channel-node-graph.ts

@@ -85,13 +85,13 @@ export const getNodesAndEdgesForChannelChain = ({
     }
   }
 
-  // Connect the last channel to the target
+  // Connect the last channel to the target, which accepts a command or query (it handles them) and consumes an event
   edges.push(
     createEdge({
       id: generatedIdForEdge(channelChain[channelChain.length - 1], target),
       source: generateIdForNode(channelChain[channelChain.length - 1]),
       target: generateIdForNode(target),
-      label: 'consumes',
+      label: ['commands', 'queries'].includes(source.collection) ? 'accepts' : 'consumes',
       data: { customColor: getColorFromString(source.data.id) },
     })
   );

package/eventcatalog/src/utils/node-graphs/domain-levels-node-graph.ts

@@ -29,6 +29,8 @@ type Tree = { domain: any; groupId: string; parentId?: string }[];
 type Owners = Map<string, { domain: any; system?: any }>;
 
 const MESSAGE_TYPES = new Set(['events', 'commands', 'queries']);
+// Commands and queries belong to what receives them (it handles them), as events do to what sends them
+const RECEIVER_OWNED_TYPES = new Set(['commands', 'queries']);
 const SERVICE_TYPES = new Set(['services', 'agents']);
 
 const systemGroupId = (system: any) => `system-group-${system.data.id}-${system.data.version}`;
@@ -44,6 +46,45 @@ const isInside = (nodes: Map<string, any>, nodeId: string, groupId: string) => {
   return false;
 };
 
+/**
+ * Whether a node (or the services another domain stands for, `receivedBy`) says
+ * it receives a message: its id, and its version (or range, or latest). Undefined
+ * when it doesn't say what it receives
+ */
+const saysItReceives = (node: any, message: any, receivedBy?: any[]): boolean | undefined => {
+  const receives = (node?.data?.service ?? node?.data?.agent)?.receives ?? receivedBy;
+  if (!receives) return undefined;
+  const { id, version } = message?.data?.message ?? {};
+  return receives.some((pointer: any) => {
+    const received = pointer.data ?? pointer;
+    return received.id === id && versionMatches(version ?? '', received.version ?? 'latest');
+  });
+};
+
+/**
+ * What a message reaches, through any channels (not the channels themselves).
+ * Past a channel, only what doesn't say it receives something else: a channel
+ * can carry other messages, to consumers of their own
+ */
+const receiversThroughChannels = (messageId: string, nodes: Map<string, any>, receiversOf: Map<string, string[]>) => {
+  const message = nodes.get(messageId);
+  const receivers: string[] = [];
+  const seen = new Set([messageId]);
+  for (let current = [messageId]; current.length > 0; ) {
+    const throughChannel = current[0] !== messageId;
+    const next = current.flatMap((nodeId) => receiversOf.get(nodeId) ?? []).filter((nodeId) => !seen.has(nodeId));
+    next.forEach((nodeId) => seen.add(nodeId));
+    receivers.push(
+      ...next.filter(
+        (nodeId) =>
+          nodes.get(nodeId)?.type !== 'channels' && (!throughChannel || saysItReceives(nodes.get(nodeId), message) !== false)
+      )
+    );
+    current = next.filter((nodeId) => nodes.get(nodeId)?.type === 'channels');
+  }
+  return receivers;
+};
+
 /** A system shown as a single node (not expanded into what's inside it) */
 const createSystemNode = (system: any, parentId?: string) => ({
   id: generateIdForNode(system),
@@ -181,16 +222,8 @@ export const collapseSystems = (
       isMessage(sender) ? [sender] : isChannel(sender) ? messagesThrough(sender, seen) : []
     );
   };
-  // Whether a node (or the services another domain stands for) says it receives a
-  // message: its id, and its version (or range, or latest)
-  const receives = (nodeId: string, messageId: string) => {
-    const data = nodesById.get(nodeId)?.data;
-    const message = nodesById.get(messageId)?.data?.message;
-    return ((data?.service ?? data?.agent)?.receives ?? receivedBy.get(nodeId) ?? []).some((pointer: any) => {
-      const { id, version } = pointer.data ?? pointer;
-      return id === message?.id && versionMatches(message?.version ?? '', version ?? 'latest');
-    });
-  };
+  const receives = (nodeId: string, messageId: string) =>
+    saysItReceives(nodesById.get(nodeId), nodesById.get(messageId), receivedBy.get(nodeId)) ?? false;
 
   // Where an edge is from and the messages it carries. A channel is one node for
   // all its messages, so an edge out of one is from each message sent through it
@@ -279,7 +312,7 @@ export const buildDomainTree = (domain: any, findDomain: (id: string, version?:
   return tree;
 };
 
-/** Which domain (and system) each service belongs to, and the domain each subdomain is in */
+/** Which domain (and system) each service or agent belongs to, and the domain each subdomain is in */
 export const collectOwners = (domains: any[]) => {
   const owners: Owners = new Map();
   const parentDomainOf = new Map<string, any>();
@@ -291,9 +324,9 @@ export const collectOwners = (domains: any[]) => {
       if (!parentDomainOf.has(subdomain.data.id)) parentDomainOf.set(subdomain.data.id, d);
     });
   });
-  // Services outside systems, unless a system already claims them
+  // Services outside systems, unless a system already claims them, and agents (systems don't have them)
   domains.forEach((d: any) =>
-    (d.data.services || []).forEach((service: any) => {
+    [...(d.data.services || []), ...(d.data.agents || [])].forEach((service: any) => {
       const serviceId = generateIdForNode(service);
       if (!owners.has(serviceId)) owners.set(serviceId, { domain: d });
     })
@@ -444,7 +477,12 @@ export const buildDomainGraph = ({
       }
       // Messages, channels, data stores: kept in the first graph they appear in
       if (nodes.has(node.id)) return;
-      nodes.set(node.id, node.parentId || !inside || SERVICE_TYPES.has(node.type) ? node : { ...node, parentId: inside });
+      // A service or agent in no domain isn't in the system whose graph it came from
+      if (SERVICE_TYPES.has(node.type)) {
+        nodes.set(node.id, { ...node, parentId: undefined, extent: undefined });
+        return;
+      }
+      nodes.set(node.id, node.parentId || !inside ? node : { ...node, parentId: inside });
     });
 
   systems.forEach(({ system, groupId: domainGroup }, index) => {
@@ -498,8 +536,8 @@ export const buildDomainGraph = ({
     if (boxId) replacedBy.set(replaced, boxId);
   });
 
-  const graphEdges = connectEdges(edges, new Map([...cardBoxes, ...replacedBy]), nodes);
-  placeMessagesWithPublishers(nodes, graphEdges, new Set(domainMessages.keys()));
+  const graphEdges = dropReceivesThroughChannels(connectEdges(edges, new Map([...cardBoxes, ...replacedBy]), nodes), nodes);
+  placeMessagesWithOwners(nodes, graphEdges, new Set(domainMessages.keys()));
   // What the services each other domain stands for receive, by the node shown for the domain
   const receivedBy = new Map<string, any[]>();
   replacedBy.forEach((nodeId, replaced) =>
@@ -546,14 +584,6 @@ const addDomainMessages = ({
   const treeDomainIds = new Set(tree.map((entry) => entry.domain.data.id));
   const otherDomainIds = new Set<string>();
   const domainMessages = new Map<string, Set<string>>();
-  // The domain each agent is in (owners only has services): the tree's versions first
-  const agentOwners = new Map<string, any>();
-  [...tree.map((entry) => entry.domain), ...domains].forEach((domain) =>
-    (domain.data.agents || []).forEach((agent: any) => {
-      const agentId = generateIdForNode(agent);
-      if (!agentOwners.has(agentId)) agentOwners.set(agentId, domain);
-    })
-  );
   // Whether a domain or service sends (or receives) the message (their messages are already looked up)
   const lists = (resource: any, key: 'sends' | 'receives', messageId: string) =>
     (resource.data[key] || []).some((message: any) => message.data && generateIdForNode(message) === messageId);
@@ -579,19 +609,19 @@ const addDomainMessages = ({
     return false;
   };
   // Whether a service in a (sub)domain's box says it sends (or receives) the message: e.g. one it sends in a
-  // message group, which its graph shows as the group rather than the message. Services only: agents in a
-  // domain aren't drawn on its diagram
+  // message group, which its graph shows as the group rather than the message. Services only: a domain's
+  // agents are only drawn when another graph brings them in
   const groupOfTreeDomain = new Map(tree.map((entry) => [entry.domain.data.id, entry.groupId]));
   const declaredIn = (groupId: string, key: 'sends' | 'receives', messageId: string) =>
     catalogServices.some((service) => {
-      if (!lists(service, key, messageId)) return false;
+      if (service.collection === 'agents' || !lists(service, key, messageId)) return false;
       const ownerGroup = groupOfTreeDomain.get(owners.get(generateIdForNode(service))?.domain.data.id);
       return !!ownerGroup && (ownerGroup === groupId || isInside(nodes, ownerGroup, groupId));
     });
   // The node standing for a service (or agent) on the other side, or none when it's in the domain
   const otherSide = (service: any) => {
     const serviceId = generateIdForNode(service);
-    const ownerDomain = owners.get(serviceId)?.domain ?? agentOwners.get(serviceId);
+    const ownerDomain = owners.get(serviceId)?.domain;
     if (ownerDomain) return treeDomainIds.has(ownerDomain.data.id) ? undefined : addOther(ownerDomain);
     if (!nodes.has(serviceId)) {
       nodes.set(serviceId, {
@@ -675,25 +705,36 @@ const addDomainMessages = ({
 /**
  * Messages are placed in the first graph they appear in, which can be a
  * system consuming them. Moves each message into the system (or domain) of the
- * services publishing it, when they're all in the same one, and each channel
- * with the messages sent through it. Messages a domain
+ * services it belongs to, when they're all in the same one: an event's
+ * publishers, a command's or query's receivers (through any channels). Each
+ * channel goes with the messages sent through it. Messages a domain
  * sends or receives itself (`kept`) stay outside its box, where its edge to them
  * is drawn.
  */
-export const placeMessagesWithPublishers = (nodes: Map<string, any>, edges: any[], kept: Set<string> = new Set()) => {
-  const publisherGroups = new Map<string, Set<string | undefined>>();
+export const placeMessagesWithOwners = (nodes: Map<string, any>, edges: any[], kept: Set<string> = new Set()) => {
+  const ownerGroups = new Map<string, Set<string | undefined>>();
+  const addOwner = (messageId: string, owner: any) =>
+    ownerGroups.set(messageId, (ownerGroups.get(messageId) ?? new Set()).add(owner.parentId));
+  const receiversOf = new Map<string, string[]>();
+  edges.forEach((edge) => receiversOf.set(edge.source, [...(receiversOf.get(edge.source) ?? []), edge.target]));
   edges.forEach((edge) => {
     const publisher = nodes.get(edge.source);
-    if (!MESSAGE_TYPES.has(nodes.get(edge.target)?.type) || !SERVICE_TYPES.has(publisher?.type)) return;
-    const groups = publisherGroups.get(edge.target) || new Set();
-    groups.add(publisher.parentId);
-    publisherGroups.set(edge.target, groups);
+    const type = nodes.get(edge.target)?.type;
+    if (!MESSAGE_TYPES.has(type) || RECEIVER_OWNED_TYPES.has(type) || !SERVICE_TYPES.has(publisher?.type)) return;
+    addOwner(edge.target, publisher);
+  });
+  nodes.forEach((message, messageId) => {
+    if (!RECEIVER_OWNED_TYPES.has(message.type)) return;
+    receiversThroughChannels(messageId, nodes, receiversOf)
+      .filter((nodeId) => SERVICE_TYPES.has(nodes.get(nodeId)?.type))
+      .forEach((nodeId) => addOwner(messageId, nodes.get(nodeId)));
   });
-  publisherGroups.forEach((groups, messageId) => {
+  ownerGroups.forEach((groups, messageId) => {
     if (kept.has(messageId)) return;
     const [parentId] = [...groups];
     const message = nodes.get(messageId);
-    if (groups.size === 1 && parentId && message.parentId !== parentId) {
+    // Owners are drawn nodes, so no parent means outside every box (e.g. a service or agent in no domain)
+    if (groups.size === 1 && message.parentId !== parentId) {
       nodes.set(messageId, { ...message, parentId, extent: undefined });
     }
   });
@@ -705,9 +746,10 @@ export const placeMessagesWithPublishers = (nodes: Map<string, any>, edges: any[
     moved = false;
     nodes.forEach((channel, channelId) => {
       if (channel.type !== 'channels' || kept.has(channelId)) return;
-      const groups = new Set((sendersOf.get(channelId) ?? []).map((sender) => nodes.get(sender)?.parentId));
+      const senders = (sendersOf.get(channelId) ?? []).filter((sender) => nodes.has(sender));
+      const groups = new Set(senders.map((sender) => nodes.get(sender).parentId));
       const [parentId] = [...groups];
-      if (groups.size === 1 && parentId && channel.parentId !== parentId) {
+      if (groups.size === 1 && channel.parentId !== parentId) {
         nodes.set(channelId, { ...channel, parentId, extent: undefined });
         moved = true;
       }
@@ -715,6 +757,27 @@ export const placeMessagesWithPublishers = (nodes: Map<string, any>, edges: any[
   }
 };
 
+/**
+ * Drops the edges drawn for domains receiving a message themselves (`domain-receives-`)
+ * when the message already reaches them through its channels, e.g. another
+ * domain listing a command in its `receives` whose service receives it from a
+ * queue: the domain is drawn receiving it from the queue, not from the command too.
+ */
+const dropReceivesThroughChannels = (edges: any[], nodes: Map<string, any>) => {
+  const isChannel = (nodeId: string) => nodes.get(nodeId)?.type === 'channels';
+  const reachesThroughChannels = (messageId: string, targetId: string) => {
+    const seen = new Set<string>();
+    for (let current = [messageId]; current.length > 0; ) {
+      const next = edges.filter((edge) => current.includes(edge.source) && isChannel(edge.target) && !seen.has(edge.target));
+      if (next.some((edge) => edges.some((out) => out.source === edge.target && out.target === targetId))) return true;
+      next.forEach((edge) => seen.add(edge.target));
+      current = next.map((edge) => edge.target);
+    }
+    return false;
+  };
+  return edges.filter((edge) => !edge.id.startsWith('domain-receives-') || !reachesThroughChannels(edge.source, edge.target));
+};
+
 /**
  * Edges pointed at the nodes replacing their ends, dropping duplicates, ones to
  * nowhere and ones between a domain and a subdomain in it.
@@ -766,15 +829,19 @@ export const addContext = (contexts: Graph[], systems: { system: any }[], nodes:
 };
 
 /**
- * Marks cross-domain communication. Messages and channels only other domains
- * send to (e.g. a message this domain consumes, and the topic it comes
+ * Marks cross-domain communication. Events and channels only other domains
+ * send to (e.g. an event this domain consumes, and the topic it comes
  * through) are another domain's: they sit outside this domain, between the
  * domain sending them and their consumers, rather than in the system that
- * consumes them. They, and this domain's messages and channels that reach
+ * consumes them. Commands and queries belong to what receives them, so those
+ * (and the channels only they're sent through) only other domains receive are
+ * another domain's, and those this domain receives are its own, whoever sends
+ * them. Messages and channels other domains send, and this domain's that reach
  * other domains, are on a cross-domain path (`data.crossDomain`), as are the
  * edges to and from them and other domains.
  */
 export const markCrossDomain = (graph: Graph, otherDomainIds: Set<string>): Graph => {
+  const nodesById = new Map(graph.nodes.map((node) => [node.id, node]));
   const sendersOf = new Map<string, string[]>();
   const receiversOf = new Map<string, string[]>();
   graph.edges.forEach((edge) => {
@@ -801,16 +868,45 @@ export const markCrossDomain = (graph: Graph, otherDomainIds: Set<string>): Grap
     return reached;
   };
   // Sent only by other domains (or their messages and channels)
-  const external = spread(new Set(otherDomainIds), (nodeId, reached) => {
+  const sentByOthers = spread(new Set(otherDomainIds), (nodeId, reached) => {
     const senders = sendersOf.get(nodeId) || [];
     return senders.length > 0 && senders.every((sender) => reached.has(sender));
   });
+  // Received only by other domains (or their messages and channels)
+  const receivedByOthers = spread(new Set(otherDomainIds), (nodeId, reached) => {
+    const receivers = receiversOf.get(nodeId) || [];
+    return receivers.length > 0 && receivers.every((receiver) => reached.has(receiver));
+  });
   // Reaching other domains (directly, or through messages and channels that do)
-  const outgoing = spread(new Set(external), (nodeId, reached) =>
+  const outgoing = spread(new Set(sentByOthers), (nodeId, reached) =>
     (receiversOf.get(nodeId) || []).some((receiver) => reached.has(receiver))
   );
 
-  const isExternalCarrier = (node: any) => external.has(node.id) && !otherDomainIds.has(node.id);
+  // A command or query, or a channel only they're sent through (by channel, worked out once: routes can split and
+  // join again)
+  const receiverOwnedChannels = new Map<string, boolean>();
+  const isReceiverOwned = (nodeId: string): boolean => {
+    const node = nodesById.get(nodeId);
+    if (MESSAGE_TYPES.has(node?.type)) return RECEIVER_OWNED_TYPES.has(node.type);
+    if (node?.type !== 'channels') return false;
+    if (!receiverOwnedChannels.has(nodeId)) {
+      // Not the receiver's while it's being worked out, so a loop of channels ends
+      receiverOwnedChannels.set(nodeId, false);
+      const carried = (sendersOf.get(nodeId) || []).filter((sender) => nodesById.has(sender) && isCarrier(nodesById.get(sender)));
+      receiverOwnedChannels.set(nodeId, carried.length > 0 && carried.every(isReceiverOwned));
+    }
+    return receiverOwnedChannels.get(nodeId)!;
+  };
+  // A command or query only other domains receive (not counting consumers of other messages on its channels)
+  const receivedOnlyByOthers = (messageId: string) => {
+    const receivers = receiversThroughChannels(messageId, nodesById, receiversOf);
+    return receivers.length > 0 && receivers.every((receiver) => otherDomainIds.has(receiver));
+  };
+  const isExternalCarrier = (node: any) => {
+    if (!isCarrier(node) || otherDomainIds.has(node.id)) return false;
+    if (RECEIVER_OWNED_TYPES.has(node.type)) return receivedOnlyByOthers(node.id);
+    return (isReceiverOwned(node.id) ? receivedByOthers : sentByOthers).has(node.id);
+  };
   const onCrossDomainPath = (nodeId: string) => outgoing.has(nodeId);
   return {
     nodes: graph.nodes.map((node) => {
@@ -858,11 +954,8 @@ export const getNodesAndEdges = (props: NodesAndEdgesProps): Promise<DomainLevel
  * or its latest when no domain has it: who sends or receives a domain's own
  * messages is matched against these.
  */
-const inVersionsUsed = (resources: any[], domains: any[], owners: Owners) => {
-  const used = new Set([
-    ...owners.keys(),
-    ...domains.flatMap((domain) => (domain.data.agents || []).map((agent: any) => generateIdForNode(agent))),
-  ]);
+const inVersionsUsed = (resources: any[], owners: Owners) => {
+  const used = new Set(owners.keys());
   const key = (resource: any) => `${resource.collection}:${resource.data.id}`;
   const usedKeys = new Set(resources.filter((resource) => used.has(generateIdForNode(resource))).map(key));
   return resources.filter((resource) =>
@@ -892,11 +985,11 @@ const buildLevels = async ({ id, version, mode = 'full', channelRenderMode }: No
   const tree = buildDomainTree(domain, findDomain);
   // The tree's domains last, so the versions shown own their services
   const { owners, parentDomainOf } = collectOwners([...domains, ...tree.map((entry) => entry.domain)]);
-  // A service the domain (or a subdomain) lists itself is shown as its own,
-  // even when a system in another domain has it too
+  // A service (or agent) the domain or a subdomain lists itself is shown as its
+  // own, even when a system in another domain has it too
   const treeDomainIds = new Set(tree.map((entry) => entry.domain.data.id));
   tree.forEach(({ domain: d }) =>
-    (d.data.services || []).forEach((service: any) => {
+    [...(d.data.services || []), ...(d.data.agents || [])].forEach((service: any) => {
       const serviceId = generateIdForNode(service);
       if (!treeDomainIds.has(owners.get(serviceId)?.domain.data.id)) owners.set(serviceId, { domain: d });
     })
@@ -953,7 +1046,7 @@ const buildLevels = async ({ id, version, mode = 'full', channelRenderMode }: No
     serviceGraphs,
     mode,
     domains,
-    catalogServices: inVersionsUsed([...services, ...agents], [...domains, ...tree.map((entry) => entry.domain)], owners),
+    catalogServices: inVersionsUsed([...services, ...agents], owners),
   });
   const context = addContext(contexts, systems, nodes);
   const graph = { nodes: [...nodes.values(), ...context.nodes], edges: [...edges, ...context.edges] };
@@ -964,8 +1057,8 @@ const buildLevels = async ({ id, version, mode = 'full', channelRenderMode }: No
   // by services not in one) are hidden too, with the nodes either side connected
   // directly. A domain without systems or subdomains has no level 1.
   if (systems.length === 0 && tree.length === 1) return layoutLevels(detailedGraph);
-  // Built from the graph before messages only other domains send were moved
-  // out of the systems consuming them, so they collapse into those systems
+  // Built from the graph before other domains' messages were moved out of the
+  // systems they were drawn in, so they collapse into those systems
   const collapsed = collapseSystems(
     { ...graph, edges: detailedGraph.edges },
     systems.map(({ system }) => system),

package/eventcatalog/src/utils/node-graphs/message-node-graph.ts

@@ -82,79 +82,6 @@ const getRoutableNodeData = (resource: RoutableResource, mode: 'simple' | 'full'
   contextMenu: getRoutableContextMenu(resource),
 });
 
-const sanitizeToolId = (name: string) =>
-  name
-    .replace(/[^a-zA-Z0-9]+/g, '-')
-    .replace(/(^-|-$)/g, '')
-    .toLowerCase();
-
-const generateIdForAgentToolNode = (agent: RoutableResource, tool: { name: string; type: string }) =>
-  `${generateIdForNode(agent)}-tool-${sanitizeToolId(`${tool.name}-${tool.type}`)}`;
-
-const appendAgentToolNodesAndEdges = ({
-  agent,
-  nodes,
-  edges,
-  mode,
-}: {
-  agent: RoutableResource;
-  nodes: Node[];
-  edges: Edge[];
-  mode: 'simple' | 'full';
-}) => {
-  if (!isAgent(agent)) return;
-
-  (agent.data.tools || []).forEach((tool) => {
-    const toolNodeId = generateIdForAgentToolNode(agent, tool);
-
-    nodes.push(
-      createNode({
-        id: toolNodeId,
-        type: 'agentTool',
-        data: {
-          mode,
-          agentTool: {
-            id: sanitizeToolId(`${tool.name}-${tool.type}`),
-            name: tool.name,
-            type: tool.type,
-            icon: tool.icon,
-            url: tool.url,
-            description: tool.description,
-          },
-          contextMenu: tool.url
-            ? [
-                {
-                  label: 'Open tool endpoint',
-                  href: tool.url,
-                  external: true,
-                },
-              ]
-            : undefined,
-        },
-        position: { x: 0, y: 0 },
-      })
-    );
-
-    edges.push(
-      createEdge({
-        id: `${generateIdForNode(agent)}-${toolNodeId}`,
-        source: generateIdForNode(agent),
-        target: toolNodeId,
-        label: 'calls tool',
-        type: 'step',
-        animated: false,
-        data: { animated: false },
-        markerEnd: {
-          type: MarkerType.ArrowClosed,
-          color: '#666',
-          width: 20,
-          height: 20,
-        },
-      })
-    );
-  });
-};
-
 const getDataProductNodeData = (resource: CollectionEntry<'data-products'>, mode: 'simple' | 'full') => ({
   title: resource.data.id,
   mode,
@@ -293,9 +220,6 @@ const getNodesAndEdges = async ({
       data: isDataProduct(producer) ? getDataProductNodeData(producer, mode) : getRoutableNodeData(producer, mode),
       position: { x: 0, y: 0 },
     });
-    if (!isDataProduct(producer)) {
-      appendAgentToolNodesAndEdges({ agent: producer, nodes, edges, mode });
-    }
 
     // Data products don't have channel configuration, so connect directly to the message
     if (isDataProduct(producer)) {
@@ -424,9 +348,6 @@ const getNodesAndEdges = async ({
       position: { x: 0, y: 0 },
       type: isDataProduct(consumer) ? 'data-products' : consumer.collection,
     });
-    if (!isDataProduct(consumer)) {
-      appendAgentToolNodesAndEdges({ agent: consumer, nodes, edges, mode });
-    }
 
     // Data products don't have channel configuration, so connect directly from the message
     if (isDataProduct(consumer)) {
@@ -656,10 +577,6 @@ const getNodesAndEdges = async ({
         position: { x: 0, y: 0 },
       })
     );
-
-    if (receiver.collection !== 'domains') {
-      appendAgentToolNodesAndEdges({ agent: receiver, nodes, edges, mode });
-    }
   };
 
   // Complete both sides of a trigger chain around the focused message:
@@ -779,7 +696,6 @@ export const getNodesAndEdgesForConsumedMessage = ({
       position: { x: 0, y: 0 },
     })
   );
-  appendAgentToolNodesAndEdges({ agent: target, nodes, edges, mode });
 
   const targetMessageConfiguration = target.data.receives?.find(
     (receive) => receive.id === message.data.id && versionMatches(receive.version, message.data.version)
@@ -889,7 +805,6 @@ export const getNodesAndEdgesForConsumedMessage = ({
         position: { x: 0, y: 0 },
       })
     );
-    appendAgentToolNodesAndEdges({ agent: producer, nodes, edges, mode });
 
     // The message is always connected directly to the producer
     edges.push(
@@ -1115,7 +1030,6 @@ export const getNodesAndEdgesForProducedMessage = ({
       position: { x: 0, y: 0 },
     })
   );
-  appendAgentToolNodesAndEdges({ agent: source, nodes, edges, mode });
 
   // Render the edge from the producer to the message
   edges.push(
@@ -1214,7 +1128,6 @@ export const getNodesAndEdgesForProducedMessage = ({
         position: { x: 0, y: 0 },
       })
     );
-    appendAgentToolNodesAndEdges({ agent: consumer, nodes, edges, mode });
 
     // Check if the consumer is consuming the message from a channel
     const consumerConfigurationForMessage = consumer.data.receives?.find(

package/eventcatalog/src/utils/node-graphs/systems-node-graph.ts

@@ -126,21 +126,17 @@ export const getNodesAndEdges = async ({
 
   // Wrap the graph in one parent "system group" boundary node. Messages,
   // channels and data stores stay in it. With confineToMembers, only this
-  // system's own services are children; other services (and their agent tools)
-  // are left outside.
-  const graphNodes = [...nodes.values()];
-  const graphEdges = [...edges.values()];
+  // system's own services are children; other services are left outside.
   const graph = {
     nodes:
       wrapInSystemGroup && nodes.size > 0
         ? wrapNodesInSystemGroup(
-            graphNodes,
-            graphEdges,
+            [...nodes.values()],
             system,
             confineToMembers ? memberServiceNodeIds(system, serviceMap) : undefined
           )
-        : graphNodes,
-    edges: graphEdges,
+        : [...nodes.values()],
+    edges: [...edges.values()],
   };
 
   return layout ? layoutNodeGraph(graph) : graph;
@@ -171,22 +167,11 @@ const withoutGroupParent = (node: any) => {
  * Wraps a system's nodes in one parent `system-group` node (sized to fit them
  * when the graph is laid out), so they visibly belong to the system.
  * When `memberIds` is set, service and agent nodes that aren't members are
- * left outside the group, and so are the tools of agents left outside.
+ * left outside the group.
  */
-const wrapNodesInSystemGroup = (systemNodes: any[], systemEdges: any[], system: any, memberIds?: Set<string>) => {
+const wrapNodesInSystemGroup = (systemNodes: any[], system: any, memberIds?: Set<string>) => {
   const groupId = `system-group-${system.data.id}-${system.data.version}`;
 
-  const outside = new Set<string>(
-    memberIds
-      ? systemNodes.filter((node) => SERVICE_NODE_TYPES.has(node.type) && !memberIds.has(node.id)).map((node) => node.id)
-      : []
-  );
-  // An agent's tools sit wherever the agent does
-  const toolIds = new Set(systemNodes.filter((node) => node.type === 'agentTool').map((node) => node.id));
-  for (const edge of systemEdges) {
-    if (outside.has(edge.source) && toolIds.has(edge.target)) outside.add(edge.target);
-  }
-
   const groupNode = {
     id: groupId,
     type: 'system-group',
@@ -203,8 +188,9 @@ const wrapNodesInSystemGroup = (systemNodes: any[], systemEdges: any[], system:
   // Parent must come before its children in the array for React Flow
   return [
     groupNode,
-    ...systemNodes.map((node) =>
-      outside.has(node.id) ? withoutGroupParent(node) : { ...node, parentId: groupId, extent: 'parent' }
-    ),
+    ...systemNodes.map((node) => {
+      if (memberIds && SERVICE_NODE_TYPES.has(node.type) && !memberIds.has(node.id)) return withoutGroupParent(node);
+      return { ...node, parentId: groupId, extent: 'parent' };
+    }),
   ];
 };

package/package.json

@@ -7,7 +7,7 @@
   },
   "license": "BUSL-1.1",
   "type": "module",
-  "version": "5.7.4",
+  "version": "5.7.5",
   "publishConfig": {
     "access": "public"
   },
@@ -141,11 +141,11 @@
     "y-protocols": "^1.0.7",
     "yjs": "^13.6.33",
     "zod": "^4.6.6",
-    "@eventcatalog/exporters": "0.1.4",
     "@eventcatalog/fitness": "0.1.1",
+    "@eventcatalog/exporters": "0.1.4",
     "@eventcatalog/linter": "1.3.1",
-    "@eventcatalog/visualiser": "^5.2.2",
-    "@eventcatalog/sdk": "2.32.0"
+    "@eventcatalog/sdk": "2.32.0",
+    "@eventcatalog/visualiser": "^5.2.3"
   },
   "devDependencies": {
     "@astrojs/check": "^0.9.10",