@inkeep/agents-manage-ui 0.6.5 → 0.7.0

package/src/features/graph/domain/__tests__/serialize.test.ts

@@ -27,7 +27,7 @@ describe('serializeGraphData', () => {
       ];
       const edges: Edge[] = [];
 
-      const result = serializeGraphData(nodes, edges);
+      const result = serializeGraphData(nodes, edges, undefined, {}, {}, {});
 
       expect((result.agents.agent1 as any).models).toBeUndefined();
     });
@@ -52,7 +52,7 @@ describe('serializeGraphData', () => {
       ];
       const edges: Edge[] = [];
 
-      const result = serializeGraphData(nodes, edges);
+      const result = serializeGraphData(nodes, edges, undefined, {}, {}, {});
 
       expect((result.agents.agent1 as any).models).toBeUndefined();
     });
@@ -77,7 +77,7 @@ describe('serializeGraphData', () => {
       ];
       const edges: Edge[] = [];
 
-      const result = serializeGraphData(nodes, edges);
+      const result = serializeGraphData(nodes, edges, undefined, {}, {}, {});
 
       expect((result.agents.agent1 as any).models).toEqual({
         base: { model: 'gpt-4' },
@@ -106,7 +106,7 @@ describe('serializeGraphData', () => {
       ];
       const edges: Edge[] = [];
 
-      const result = serializeGraphData(nodes, edges);
+      const result = serializeGraphData(nodes, edges, undefined, {}, {}, {});
 
       expect((result.agents.agent1 as any).models).toEqual({
         base: undefined,
@@ -135,7 +135,7 @@ describe('serializeGraphData', () => {
       ];
       const edges: Edge[] = [];
 
-      const result = serializeGraphData(nodes, edges);
+      const result = serializeGraphData(nodes, edges, undefined, {}, {}, {});
 
       expect((result.agents.agent1 as any).models).toEqual({
         base: undefined,
@@ -164,7 +164,7 @@ describe('serializeGraphData', () => {
       ];
       const edges: Edge[] = [];
 
-      const result = serializeGraphData(nodes, edges);
+      const result = serializeGraphData(nodes, edges, undefined, {}, {}, {});
 
       expect((result.agents.agent1 as any).models).toEqual({
         base: { model: 'gpt-4' },
@@ -189,7 +189,7 @@ describe('serializeGraphData', () => {
       ];
       const edges: Edge[] = [];
 
-      const result = serializeGraphData(nodes, edges);
+      const result = serializeGraphData(nodes, edges, undefined, {}, {}, {});
 
       expect((result.agents.agent1 as any).models).toBeUndefined();
     });
@@ -213,15 +213,9 @@ describe('serializeGraphData', () => {
           type: NodeType.MCP,
           position: { x: 200, y: 0 },
           data: {
-            id: 'mcp1',
+            toolId: 'mcp1',
             name: 'Test MCP Server',
-            config: { type: 'mcp', mcp: { server: { url: 'test://server' } } },
             tempSelectedTools: ['tool1', 'tool2'],
-            tenantId: 'test-tenant',
-            projectId: 'test-project',
-            status: 'unknown',
-            createdAt: new Date(),
-            updatedAt: new Date(),
           } as MCPNodeData,
         },
       ];
@@ -235,13 +229,13 @@ describe('serializeGraphData', () => {
         },
       ];
 
-      const result = serializeGraphData(nodes, edges);
+      const result = serializeGraphData(nodes, edges, undefined, {}, {}, {});
 
       expect((result.agents.agent1 as any).canUse).toBeDefined();
       expect((result.agents.agent1 as any).canUse).toHaveLength(1);
       expect((result.agents.agent1 as any).canUse[0]).toEqual({
         toolId: 'mcp1',
-        toolSelection: ['tool1', 'tool2']
+        toolSelection: ['tool1', 'tool2'],
       });
     });
 
@@ -263,15 +257,9 @@ describe('serializeGraphData', () => {
           type: NodeType.MCP,
           position: { x: 200, y: 0 },
           data: {
-            id: 'mcp1',
+            toolId: 'mcp1',
             name: 'Test MCP Server',
-            config: { type: 'mcp', mcp: { server: { url: 'test://server' } } },
             tempSelectedTools: null, // null means all tools selected
-            tenantId: 'test-tenant',
-            projectId: 'test-project',
-            status: 'unknown',
-            createdAt: new Date(),
-            updatedAt: new Date(),
           } as MCPNodeData,
         },
       ];
@@ -285,14 +273,14 @@ describe('serializeGraphData', () => {
         },
       ];
 
-      const result = serializeGraphData(nodes, edges);
+      const result = serializeGraphData(nodes, edges, undefined, {}, {}, {});
 
       // When tempSelectedTools is null, all tools should be selected (toolSelection: null)
       expect((result.agents.agent1 as any).canUse).toBeDefined();
       expect((result.agents.agent1 as any).canUse).toHaveLength(1);
       expect((result.agents.agent1 as any).canUse[0]).toEqual({
         toolId: 'mcp1',
-        toolSelection: null
+        toolSelection: null,
       });
     });
 
@@ -313,15 +301,9 @@ describe('serializeGraphData', () => {
           type: NodeType.MCP,
           position: { x: 200, y: 0 },
           data: {
-            id: 'mcp1',
+            toolId: 'mcp1',
             name: 'Test MCP Server',
-            config: { type: 'mcp', mcp: { server: { url: 'test://server' } } },
             tempSelectedTools: [], // empty array means no tools selected
-            tenantId: 'test-tenant',
-            projectId: 'test-project',
-            status: 'unknown',
-            createdAt: new Date(),
-            updatedAt: new Date(),
           } as MCPNodeData,
         },
       ];
@@ -335,13 +317,13 @@ describe('serializeGraphData', () => {
         },
       ];
 
-      const result = serializeGraphData(nodes, edges);
+      const result = serializeGraphData(nodes, edges, undefined, {}, {}, {});
 
       expect((result.agents.agent1 as any).canUse).toBeDefined();
       expect((result.agents.agent1 as any).canUse).toHaveLength(1);
       expect((result.agents.agent1 as any).canUse[0]).toEqual({
         toolId: 'mcp1',
-        toolSelection: []
+        toolSelection: [],
       });
     });
 
@@ -362,15 +344,9 @@ describe('serializeGraphData', () => {
           type: NodeType.MCP,
           position: { x: 200, y: 0 },
           data: {
-            id: 'mcp1',
+            toolId: 'mcp1',
             name: 'Test MCP Server',
-            config: { type: 'mcp', mcp: { server: { url: 'test://server' } } },
             // no tempSelectedTools property
-            tenantId: 'test-tenant',
-            projectId: 'test-project',
-            status: 'unknown',
-            createdAt: new Date(),
-            updatedAt: new Date(),
           } as MCPNodeData,
         },
       ];
@@ -384,7 +360,7 @@ describe('serializeGraphData', () => {
         },
       ];
 
-      const result = serializeGraphData(nodes, edges);
+      const result = serializeGraphData(nodes, edges, undefined, {}, {}, {});
 
       // selectedTools should not be created if tempSelectedTools is undefined
       expect((result.agents.agent1 as any).selectedTools).toBeUndefined();
@@ -409,15 +385,9 @@ describe('serializeGraphData', () => {
           type: NodeType.MCP,
           position: { x: 200, y: 0 },
           data: {
-            id: 'mcp1',
+            toolId: 'mcp1',
             name: 'Test MCP Server',
-            config: { type: 'mcp', mcp: { server: { url: 'test://server' } } },
             // tempSelectedTools is undefined (user didn't interact with UI)
-            tenantId: 'test-tenant',
-            projectId: 'test-project',
-            status: 'unknown',
-            createdAt: new Date(),
-            updatedAt: new Date(),
           } as MCPNodeData,
         },
       ];
@@ -431,7 +401,7 @@ describe('serializeGraphData', () => {
         },
       ];
 
-      const result = serializeGraphData(nodes, edges);
+      const result = serializeGraphData(nodes, edges, undefined, {}, {}, {});
 
       // When tempSelectedTools is undefined and there's an edge to MCP tool,
       // the toolSelection will be null (all tools selected by default)
@@ -439,7 +409,7 @@ describe('serializeGraphData', () => {
       expect((result.agents.agent1 as any).canUse).toHaveLength(1);
       expect((result.agents.agent1 as any).canUse[0]).toEqual({
         toolId: 'mcp1',
-        toolSelection: null  // null means all tools are selected
+        toolSelection: null, // null means all tools are selected
       });
     });
   });

package/src/features/graph/domain/deserialize.ts

@@ -14,7 +14,7 @@ import type {
   FullGraphDefinition,
   InternalAgentDefinition,
 } from '@/lib/types/graph-full';
-import type { MCPTool } from '@/lib/types/tools';
+
 import { formatJsonField } from '@/lib/utils';
 
 interface TransformResult {
@@ -101,10 +101,7 @@ function applyDagreLayout(nodes: Node[], edges: Edge[]): Node[] {
   });
 }
 
-export function deserializeGraphData(
-  data: FullGraphDefinition,
-  toolLookup?: Record<string, MCPTool>
-): TransformResult {
+export function deserializeGraphData(data: FullGraphDefinition): TransformResult {
   const nodes: Node[] = [];
   const edges: Edge[] = [];
 
@@ -213,7 +210,7 @@ export function deserializeGraphData(
             id: toolNodeId,
             type: NodeType.MCP,
             position: { x: 0, y: 0 },
-            data: { id: tool.id, ...tool },
+            data: { toolId: tool.id },
           };
           nodes.push(toolNode);
 
@@ -228,33 +225,15 @@ export function deserializeGraphData(
           edges.push(agentToToolEdge);
         }
       } else {
-        // Tools are project-scoped, use the tool lookup if available
+        // Tools are project-scoped - just store the tool ID
         for (const canUseItem of agent.canUse) {
           const toolId = canUseItem.toolId;
-          const tool = toolLookup?.[toolId];
           const toolNodeId = nanoid();
           const toolNode: Node = {
             id: toolNodeId,
             type: NodeType.MCP,
             position: { x: 0, y: 0 },
-            data: tool
-              ? {
-                  id: tool.id,
-                  name: tool.name,
-                  description: '', // MCPTool doesn't have a description field at top level
-                  type: 'mcp',
-                  config: tool.config || {},
-                  status: tool.status,
-                  availableTools: tool.availableTools,
-                  selectedTools: canUseItem.toolSelection, // Use toolSelection from canUseItem
-                }
-              : {
-                  id: toolId,
-                  name: toolId,
-                  description: 'Project-scoped tool',
-                  type: 'project-scoped',
-                  config: {},
-                },
+            data: { toolId },
           };
           nodes.push(toolNode);
 

package/src/features/graph/domain/serialize.ts

@@ -9,7 +9,10 @@ import type { DataComponent } from '@/lib/api/data-components';
 import type { FullGraphDefinition } from '@/lib/types/graph-full';
 
 // Extract the internal agent type from the union
-type InternalAgent = Extract<FullGraphDefinition['agents'][string], { canUse: Array<{ toolId: string; toolSelection?: string[] | null }> }>;
+type InternalAgent = Extract<
+  FullGraphDefinition['agents'][string],
+  { canUse: Array<{ toolId: string; toolSelection?: string[] | null }> }
+>;
 
 type ExternalAgent = {
   id: string;
@@ -82,7 +85,8 @@ export function serializeGraphData(
   edges: Edge[],
   metadata?: GraphMetadata,
   dataComponentLookup?: Record<string, DataComponent>,
-  artifactComponentLookup?: Record<string, ArtifactComponent>
+  artifactComponentLookup?: Record<string, ArtifactComponent>,
+  selectedToolsLookup?: Record<string, Record<string, string[]>>
 ): FullGraphDefinition {
   const agents: Record<string, ExtendedAgent> = {};
   // Note: Tools are now project-scoped and not included in graph serialization
@@ -108,13 +112,56 @@ export function serializeGraphData(
 
       const stopWhen = (node.data as any).stopWhen;
 
-      // Convert tools and selectedTools to canUse array
-      const tools = (node.data as any).tools || [];
-      const selectedTools = (node.data as any).selectedTools || {};
-      const canUse = tools.map((toolId: string) => ({
-        toolId,
-        toolSelection: selectedTools[toolId] || null
-      }));
+      // Build canUse array from edges connecting this agent to MCP nodes
+      const canUse: Array<{ toolId: string; toolSelection?: string[] | null }> = [];
+
+      // Find edges from this agent to MCP nodes
+      const agentToMcpEdges = edges.filter(
+        (edge) =>
+          edge.source === node.id &&
+          nodes.some((n) => n.id === edge.target && n.type === NodeType.MCP)
+      );
+
+      for (const edge of agentToMcpEdges) {
+        const mcpNode = nodes.find((n) => n.id === edge.target);
+
+        if (mcpNode && mcpNode.type === NodeType.MCP) {
+          const toolId = (mcpNode.data as any).toolId;
+
+          if (toolId) {
+            // Get selected tools from MCP node's tempSelectedTools
+            const tempSelectedTools = (mcpNode.data as any).tempSelectedTools;
+            let toolSelection: string[] | null = null;
+
+            if (tempSelectedTools !== undefined) {
+              // User has made changes to tool selection in the UI
+              if (Array.isArray(tempSelectedTools)) {
+                toolSelection = tempSelectedTools;
+              } else if (tempSelectedTools === null) {
+                toolSelection = null; // All tools selected
+              }
+            } else {
+              // No changes made to tool selection - preserve existing selection
+              if (
+                selectedToolsLookup &&
+                selectedToolsLookup[agentId] &&
+                selectedToolsLookup[agentId][toolId] !== undefined
+              ) {
+                // Get existing selection from saved data
+                toolSelection = selectedToolsLookup[agentId][toolId];
+              } else {
+                // Default to all tools selected when no existing data found
+                toolSelection = null;
+              }
+            }
+
+            canUse.push({
+              toolId,
+              toolSelection,
+            });
+          }
+        }
+      }
 
       const agent: ExtendedAgent = {
         id: agentId,
@@ -151,10 +198,6 @@ export function serializeGraphData(
       }
 
       agents[agentId] = agent;
-    } else if (node.type === NodeType.MCP) {
-      // Note: Tools are now project-scoped and not processed during graph serialization
-      // Tool nodes in the UI are handled separately at the project level
-      console.log('Skipping MCP tool node during graph serialization (tools are project-scoped)');
     }
   }
 
@@ -209,45 +252,6 @@ export function serializeGraphData(
           addRelationship(targetAgent, 'canDelegateTo', sourceAgentId);
         }
       }
-    } else if (edge.type === EdgeType.Default) {
-      const sourceAgentNode = nodes.find((node) => node.id === edge.source);
-      const sourceAgentId = (sourceAgentNode?.data.id || sourceAgentNode?.id) as string;
-      const sourceAgent: ExtendedAgent = agents[sourceAgentId];
-      const targetToolNode = nodes.find((node) => node.id === edge.target);
-      if (sourceAgent && targetToolNode && sourceAgent.type === 'internal') {
-        const toolId = (targetToolNode.data as any).id as string;
-        const internalAgent = sourceAgent as InternalAgent & {
-          dataComponents: string[];
-          artifactComponents: string[];
-          models?: GraphMetadata['models'];
-          type: 'internal';
-        };
-
-        // Check if tool is already in canUse array
-        const existingCanUse = internalAgent.canUse.find(item => item.toolId === toolId);
-        if (!existingCanUse) {
-          internalAgent.canUse.push({
-            toolId,
-            toolSelection: null
-          });
-        }
-
-        // Only override toolSelection if user made changes in the UI for this specific tool
-        const userSelectedTools = (targetToolNode.data as any).tempSelectedTools;
-        if (userSelectedTools !== undefined) {
-          // User has made selections in the UI for this tool
-          const canUseItem = internalAgent.canUse.find(item => item.toolId === toolId);
-          if (canUseItem) {
-            if (userSelectedTools === null) {
-              // User selected all tools - set to null (null = all)
-              canUseItem.toolSelection = null;
-            } else {
-              // User selected specific tools (including empty array for "none selected")
-              canUseItem.toolSelection = userSelectedTools;
-            }
-          }
-        }
-      }
     }
   }
 

package/src/lib/api/tools.ts

@@ -122,97 +122,7 @@ export async function deleteMCPTool(
   validateTenantId(tenantId);
   validateProjectId(projectId);
 
-  await makeManagementApiRequest<void>(
-    `tenants/${tenantId}/projects/${projectId}/tools/${id}`,
-    {
-      method: 'DELETE',
-    }
-  );
-}
-
-/**
- * Check health of an MCP tool
- */
-export async function checkMCPToolHealth(
-  tenantId: string,
-  projectId: string,
-  id: string
-): Promise<{
-  tool: McpTool;
-  healthCheck: {
-    status: McpTool['status'];
-    error?: string;
-  };
-}> {
-  validateTenantId(tenantId);
-  validateProjectId(projectId);
-
-  const response = await makeManagementApiRequest<
-    SingleResponse<{
-      tool: McpTool;
-      healthCheck: {
-        status: McpTool['status'];
-        error?: string;
-      };
-    }>
-  >(`tenants/${tenantId}/projects/${projectId}/tools/${id}/health-check`, {
-    method: 'POST',
+  await makeManagementApiRequest<void>(`tenants/${tenantId}/projects/${projectId}/tools/${id}`, {
+    method: 'DELETE',
   });
-
-  return response.data;
-}
-
-/**
- * Get available tools from an MCP server
- */
-export async function getMCPToolAvailableTools(
-  tenantId: string,
-  projectId: string,
-  id: string
-): Promise<{
-  availableTools: Array<{
-    name: string;
-    description?: string;
-    inputSchema?: Record<string, unknown>;
-  }>;
-  lastSync?: string;
-  status: McpTool['status'];
-}> {
-  validateTenantId(tenantId);
-  validateProjectId(projectId);
-
-  const response = await makeManagementApiRequest<
-    SingleResponse<{
-      availableTools: Array<{
-        name: string;
-        description?: string;
-        inputSchema?: Record<string, unknown>;
-      }>;
-      lastSync?: string;
-      status: McpTool['status'];
-    }>
-  >(`tenants/${tenantId}/projects/${projectId}/tools/${id}/available-tools`);
-
-  return response.data;
-}
-
-/**
- * Sync tool definitions from an MCP server
- */
-export async function syncMCPTool(
-  tenantId: string,
-  projectId: string,
-  id: string
-): Promise<McpTool> {
-  validateTenantId(tenantId);
-  validateProjectId(projectId);
-
-  const response = await makeManagementApiRequest<SingleResponse<McpTool>>(
-    `tenants/${tenantId}/projects/${projectId}/tools/${id}/sync`,
-    {
-      method: 'POST',
-    }
-  );
-
-  return response.data;
 }

package/src/lib/utils/orphaned-tools-detector.ts

@@ -0,0 +1,145 @@
+import type { Node } from '@xyflow/react';
+import { getActiveTools } from '@/app/utils/active-tools';
+import type { MCPNodeData } from '@/components/graph/configuration/node-types';
+import { NodeType } from '@/components/graph/configuration/node-types';
+import type { MCPTool } from '@/lib/types/tools';
+
+export interface OrphanedToolsInfo {
+  nodeId: string;
+  nodeName: string;
+  orphanedTools: string[];
+}
+
+export interface OrphanedToolsDetectionResult {
+  hasOrphanedTools: boolean;
+  orphanedToolsByNode: OrphanedToolsInfo[];
+  totalOrphanedCount: number;
+}
+
+/**
+ * Simplified API that combines detection and message creation
+ * Returns null if no orphaned tools found, otherwise returns the warning message
+ */
+export function detectOrphanedToolsAndGetWarning(
+  nodes: Node[],
+  selectedToolsLookup: Record<string, Record<string, string[]>>,
+  toolLookup: Record<string, MCPTool>
+): string | null {
+  const result = detectOrphanedToolsInGraph(nodes, selectedToolsLookup, toolLookup);
+  return result.hasOrphanedTools ? createOrphanedToolsWarningMessage(result) : null;
+}
+
+/**
+ * Extract shared logic for getting selected tools for a node
+ * This replaces the duplicated logic between detector and MCP node editor
+ */
+export function getCurrentSelectedToolsForNode(
+  node: Node<MCPNodeData>,
+  selectedToolsLookup: Record<string, Record<string, string[]>>
+): string[] | null {
+  // First check if we have temporary selections stored on the node (from recent clicks)
+  if ((node.data as any).tempSelectedTools !== undefined) {
+    return (node.data as any).tempSelectedTools;
+  }
+
+  // Otherwise, get from the database/initial state
+  const allSelectedTools = new Set<string>();
+  let hasAnyData = false;
+  let hasEmptyArray = false;
+  let hasNullValue = false;
+
+  Object.values(selectedToolsLookup).forEach((agentTools) => {
+    const toolsForThisMCP = agentTools[node.data.toolId];
+    if (toolsForThisMCP !== undefined) {
+      hasAnyData = true;
+      if (Array.isArray(toolsForThisMCP) && toolsForThisMCP.length === 0) {
+        hasEmptyArray = true;
+      } else if (toolsForThisMCP === null) {
+        hasNullValue = true;
+      } else if (Array.isArray(toolsForThisMCP)) {
+        toolsForThisMCP.forEach((tool) => {
+          allSelectedTools.add(tool);
+        });
+      }
+    }
+  });
+
+  if (hasNullValue) return null;
+  if (hasEmptyArray) return [];
+  if (!hasAnyData) return null;
+
+  return Array.from(allSelectedTools);
+}
+
+/**
+ * Detects orphaned tools across all MCP nodes in the graph
+ * Orphaned tools are tools that were selected but are no longer available in the MCP server
+ */
+export function detectOrphanedToolsInGraph(
+  nodes: Node[],
+  selectedToolsLookup: Record<string, Record<string, string[]>>,
+  toolLookup: Record<string, MCPTool>
+): OrphanedToolsDetectionResult {
+  const orphanedToolsByNode: OrphanedToolsInfo[] = [];
+
+  // Find all MCP nodes
+  const mcpNodes = nodes.filter((node): node is Node<MCPNodeData> => node.type === NodeType.MCP);
+
+  for (const node of mcpNodes) {
+    const toolData = toolLookup[node.data.toolId];
+    if (!toolData) continue; // Skip if tool data not found
+
+    const activeTools = getActiveTools({
+      availableTools: toolData.availableTools,
+      activeTools: toolData.config?.mcp?.activeTools,
+    });
+
+    const selectedTools = getCurrentSelectedToolsForNode(node, selectedToolsLookup);
+
+    // Find orphaned tools for this node
+    const orphanedTools =
+      selectedTools && Array.isArray(selectedTools)
+        ? selectedTools.filter((toolName) => !activeTools?.some((tool) => tool.name === toolName))
+        : [];
+
+    if (orphanedTools.length > 0) {
+      orphanedToolsByNode.push({
+        nodeId: node.data.toolId,
+        nodeName: node.data.name || toolData.name || 'Unnamed MCP Server',
+        orphanedTools,
+      });
+    }
+  }
+
+  const totalOrphanedCount = orphanedToolsByNode.reduce(
+    (total, nodeInfo) => total + nodeInfo.orphanedTools.length,
+    0
+  );
+
+  return {
+    hasOrphanedTools: orphanedToolsByNode.length > 0,
+    orphanedToolsByNode,
+    totalOrphanedCount,
+  };
+}
+
+/**
+ * Creates a user-friendly warning message for orphaned tools
+ * Assumes result.hasOrphanedTools is true (should be checked by caller)
+ */
+export function createOrphanedToolsWarningMessage(result: OrphanedToolsDetectionResult): string {
+  const nodeCount = result.orphanedToolsByNode.length;
+  const toolCount = result.totalOrphanedCount;
+
+  if (nodeCount === 1) {
+    const nodeInfo = result.orphanedToolsByNode[0];
+    const toolList = nodeInfo.orphanedTools.join(', ');
+    const toolText = toolCount > 1 ? 'tools' : 'tool';
+    const verbText = toolCount > 1 ? 'are' : 'is';
+    const pronounText = toolCount > 1 ? 'These tools' : 'This tool';
+
+    return `The MCP server "${nodeInfo.nodeName}" has ${toolCount} selected ${toolText} that ${verbText} no longer available: ${toolList}. ${pronounText} will not be available at runtime. Please update your tool selections.`;
+  }
+
+  return `${nodeCount} MCP servers have a total of ${toolCount} selected tools that are no longer available. These orphaned tools will not be available at runtime. Please update your tool selections.`;
+}