@inkeep/agents-manage-ui 0.26.1 → 0.27.0

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

@@ -2,6 +2,7 @@ import type { Edge, Node } from '@xyflow/react';
 import type {
   AgentToolConfigLookup,
   SubAgentExternalAgentConfigLookup,
+  SubAgentTeamAgentConfigLookup,
 } from '@/components/agent/agent';
 import type { AgentMetadata } from '@/components/agent/configuration/agent-types';
 import type { A2AEdgeData } from '@/components/agent/configuration/edge-types';
@@ -11,6 +12,7 @@ import type { ArtifactComponent } from '@/lib/api/artifact-components';
 import type { DataComponent } from '@/lib/api/data-components';
 import type { FullAgentDefinition, InternalAgentDefinition } from '@/lib/types/agent-full';
 import type { ExternalAgent } from '@/lib/types/external-agents';
+import type { TeamAgent } from '@/lib/types/team-agents';
 import { generateId } from '@/lib/utils/id-utils';
 
 export type ExtendedAgent = InternalAgentDefinition & {
@@ -76,10 +78,12 @@ export function serializeAgentData(
   dataComponentLookup?: Record<string, DataComponent>,
   artifactComponentLookup?: Record<string, ArtifactComponent>,
   agentToolConfigLookup?: AgentToolConfigLookup,
-  subAgentExternalAgentConfigLookup?: SubAgentExternalAgentConfigLookup
+  subAgentExternalAgentConfigLookup?: SubAgentExternalAgentConfigLookup,
+  subAgentTeamAgentConfigLookup?: SubAgentTeamAgentConfigLookup
 ): FullAgentDefinition {
   const subAgents: Record<string, ExtendedAgent> = {};
   const externalAgents: Record<string, ExternalAgent> = {};
+  const teamAgents: Record<string, TeamAgent> = {};
   const functionTools: Record<string, any> = {};
   const functions: Record<string, any> = {};
   // Note: Tools are now project-scoped and not included in agent serialization
@@ -268,14 +272,61 @@ export function serializeAgentData(
       };
 
       externalAgents[externalAgentId] = externalAgent;
+    } else if (node.type === NodeType.TeamAgent) {
+      const teamAgentId = (node.data.id as string) || node.id;
+      const teamAgent: TeamAgent & {
+        relationshipId: string | null;
+        tempHeaders: Record<string, string> | null;
+      } = {
+        id: teamAgentId,
+        name: node.data.name as string,
+        description: (node.data.description as string) || '',
+        tempHeaders: (node.data as any).tempHeaders || null,
+        relationshipId: (node.data.relationshipId as string) || null,
+      };
+      teamAgents[teamAgentId] = teamAgent;
     }
     // External agent nodes are skipped - they are project-scoped resources
   }
 
+  const subAgentExternalDelegateMap: Record<string, Record<string, any>> = {}; // subAgentId -> relationshipId ->  relationship data
+  const newSubAgentExternalDelegateMap: Record<string, any> = {}; // subAgentId -> relationship data
+  const subAgentTeamDelegateMap: Record<string, Record<string, any>> = {}; // subAgentId -> relationshipId ->  relationship data
+  const newSubAgentTeamDelegateMap: Record<string, any> = {}; // subAgentId -> relationship data
+
+  // Populate delegate maps from existing agent data to avoid linear searches
+  Object.entries(subAgents).forEach(([subAgentId, agent]) => {
+    if (agent.canDelegateTo) {
+      agent.canDelegateTo.forEach((delegate) => {
+        if (typeof delegate === 'object') {
+          if ('externalAgentId' in delegate) {
+            // External agent delegation
+            if (!subAgentExternalDelegateMap[subAgentId]) {
+              subAgentExternalDelegateMap[subAgentId] = {};
+            }
+            if (delegate.subAgentExternalAgentRelationId) {
+              subAgentExternalDelegateMap[subAgentId][delegate.subAgentExternalAgentRelationId] =
+                delegate;
+            }
+          } else if ('agentId' in delegate) {
+            // Team agent delegation
+            if (!subAgentTeamDelegateMap[subAgentId]) {
+              subAgentTeamDelegateMap[subAgentId] = {};
+            }
+            if (delegate.subAgentTeamAgentRelationId) {
+              subAgentTeamDelegateMap[subAgentId][delegate.subAgentTeamAgentRelationId] = delegate;
+            }
+          }
+        }
+      });
+    }
+  });
+
   for (const edge of edges) {
     if (
       edge.type === EdgeType.A2A ||
       edge.type === EdgeType.A2AExternal ||
+      edge.type === EdgeType.A2ATeam ||
       edge.type === EdgeType.SelfLoop
     ) {
       const sourceAgentNode = nodes.find((node) => node.id === edge.source);
@@ -287,7 +338,9 @@ export function serializeAgentData(
 
       const targetAgent: ExtendedAgent | undefined = subAgents[targetSubAgentId];
       const targetExternalAgent: ExternalAgent | undefined = externalAgents[targetSubAgentId];
+      const targetTeamAgent: TeamAgent | undefined = teamAgents[targetSubAgentId];
       const isTargetExternal = targetExternalAgent !== undefined;
+      const isTargetTeamAgent = targetTeamAgent !== undefined;
 
       if (!sourceAgent || !(edge.data as any)?.relationships) {
         continue;
@@ -301,6 +354,7 @@ export function serializeAgentData(
         relationshipType: 'canTransferTo' | 'canDelegateTo',
         targetId: string,
         isExternal: boolean = false,
+        isTeamAgent: boolean = false,
         headers?: Record<string, string>,
         relationshipId?: string
       ) => {
@@ -311,13 +365,6 @@ export function serializeAgentData(
 
           // External agents always use object format
           if (isExternal) {
-            const existingIndex = agent.canDelegateTo.findIndex(
-              (item) =>
-                typeof item === 'object' &&
-                item.externalAgentId === targetId &&
-                item.subAgentExternalAgentRelationId === relationshipId
-            );
-
             const relationshipData: any = {
               externalAgentId: targetId,
               headers: headers ?? null,
@@ -328,12 +375,41 @@ export function serializeAgentData(
               relationshipData.subAgentExternalAgentRelationId = relationshipId;
             }
 
-            if (existingIndex !== -1) {
-              // Update existing relationship
-              agent.canDelegateTo[existingIndex] = relationshipData;
+            // Store relationship in map - we'll rebuild canDelegateTo arrays at the end
+            if (relationshipId) {
+              if (!subAgentExternalDelegateMap[agent.id]) {
+                subAgentExternalDelegateMap[agent.id] = {};
+              }
+              subAgentExternalDelegateMap[agent.id][relationshipId] = relationshipData;
             } else {
-              // Add new relationship
-              agent.canDelegateTo.push(relationshipData);
+              if (!newSubAgentExternalDelegateMap[agent.id]) {
+                newSubAgentExternalDelegateMap[agent.id] = {};
+              }
+              newSubAgentExternalDelegateMap[agent.id] = relationshipData;
+            }
+          } else if (isTeamAgent) {
+            // Team agents use object format with agentId
+            const relationshipData: any = {
+              agentId: targetId,
+              headers: headers ?? null,
+            };
+
+            // Only include relationshipId if it's not null (schema expects optional, not nullable)
+            if (relationshipId) {
+              relationshipData.subAgentTeamAgentRelationId = relationshipId;
+            }
+
+            // Store relationship in map - we'll rebuild canDelegateTo arrays at the end
+            if (relationshipId) {
+              if (!subAgentTeamDelegateMap[agent.id]) {
+                subAgentTeamDelegateMap[agent.id] = {};
+              }
+              subAgentTeamDelegateMap[agent.id][relationshipId] = relationshipData;
+            } else {
+              if (!newSubAgentTeamDelegateMap[agent.id]) {
+                newSubAgentTeamDelegateMap[agent.id] = {};
+              }
+              newSubAgentTeamDelegateMap[agent.id] = relationshipData;
             }
           } else {
             // Internal agents use string format
@@ -378,6 +454,7 @@ export function serializeAgentData(
             'canDelegateTo',
             targetSubAgentId,
             true, // isExternal
+            false, // isTeamAgent
             externalAgentHeaders,
             relationshipId
           );
@@ -385,6 +462,43 @@ export function serializeAgentData(
         continue;
       }
 
+      // Handle edges to team agents (only delegation is allowed)
+      if (isTargetTeamAgent) {
+        if (relationships.delegateSourceToTarget) {
+          const tempHeaders = (targetAgentNode as any).data?.tempHeaders;
+          let teamAgentHeaders: Record<string, string> | undefined;
+          const relationshipId = (targetAgentNode as any).data?.relationshipId;
+
+          if (tempHeaders !== undefined) {
+            if (
+              typeof tempHeaders === 'object' &&
+              tempHeaders !== null &&
+              !Array.isArray(tempHeaders)
+            ) {
+              teamAgentHeaders = tempHeaders;
+            }
+          } else {
+            const existingConfig = relationshipId
+              ? subAgentTeamAgentConfigLookup?.[sourceSubAgentId]?.[relationshipId]
+              : null;
+            if (existingConfig?.headers) {
+              teamAgentHeaders = existingConfig.headers;
+            }
+          }
+
+          addRelationship(
+            sourceAgent,
+            'canDelegateTo',
+            targetSubAgentId,
+            false, // isExternal
+            true, // isTeamAgent
+            teamAgentHeaders,
+            relationshipId
+          );
+        }
+        continue;
+      }
+
       // Handle edges between internal agents
       if (targetAgent) {
         // Process transfer relationships
@@ -505,6 +619,32 @@ export function serializeAgentData(
     };
   }
 
+  // Rebuild canDelegateTo arrays from delegate maps to ensure consistency
+  Object.entries(subAgents).forEach(([subAgentId, agent]) => {
+    if (agent.canDelegateTo) {
+      // Start with internal agent delegations (string format)
+      const internalDelegations = agent.canDelegateTo.filter(
+        (delegate) => typeof delegate === 'string'
+      );
+
+      // Add external agent delegations from map
+      const externalDelegations = Object.values(subAgentExternalDelegateMap[subAgentId] || {});
+
+      // Add team agent delegations from map
+      const teamDelegations = Object.values(subAgentTeamDelegateMap[subAgentId] || {});
+
+      // Rebuild the array with all delegations
+      agent.canDelegateTo = [...internalDelegations, ...externalDelegations, ...teamDelegations];
+
+      if (newSubAgentExternalDelegateMap[subAgentId]) {
+        agent.canDelegateTo.push(newSubAgentExternalDelegateMap[subAgentId]);
+      }
+      if (newSubAgentTeamDelegateMap[subAgentId]) {
+        agent.canDelegateTo.push(newSubAgentTeamDelegateMap[subAgentId]);
+      }
+    }
+  });
+
   return result;
 }
 

package/src/lib/actions/agent-full.ts

@@ -13,6 +13,7 @@ import {
   createFullAgent as apiCreateFullAgent,
   deleteFullAgent as apiDeleteFullAgent,
   fetchAgents as apiFetchAgents,
+  fetchTeamAgents as apiFetchTeamAgents,
   getFullAgent as apiGetFullAgent,
   updateFullAgent as apiUpdateFullAgent,
 } from '../api/agent-full-client';
@@ -21,6 +22,7 @@ import {
   type FullAgentDefinition,
   FullAgentDefinitionSchema,
 } from '../types/agent-full';
+import type { TeamAgent } from '../types/team-agents';
 
 /**
  * Result type for server actions - follows a consistent pattern
@@ -55,6 +57,28 @@ export async function getAllAgentsAction(
   }
 }
 
+/**
+ * Fetch barebones metadata for all agents in a project to be used with team agent relations
+ */
+export async function fetchTeamAgentsAction(
+  tenantId: string,
+  projectId: string
+): Promise<ActionResult<TeamAgent[]>> {
+  try {
+    const response = await apiFetchTeamAgents(tenantId, projectId);
+    return {
+      success: true,
+      data: response,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Failed to fetch team agents',
+      code: 'unknown_error',
+    };
+  }
+}
+
 /**
  * Create a new full agent
  */

package/src/lib/api/agent-full-client.ts

@@ -14,6 +14,7 @@ import type {
 } from '../types/agent-full';
 import { ApiError } from '../types/errors';
 import type { ListResponse } from '../types/response';
+import type { TeamAgent } from '../types/team-agents';
 import { makeManagementApiRequest } from './api-config';
 import { validateProjectId, validateTenantId } from './resource-validation';
 
@@ -29,6 +30,23 @@ export async function fetchAgents(
   );
 }
 
+/**
+ * Fetch barebones metadata for all agents in a project to be used with team agent relations
+ */
+export async function fetchTeamAgents(tenantId: string, projectId: string): Promise<TeamAgent[]> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  const agents = await fetchAgents(tenantId, projectId);
+  return agents.data.map((agent) => {
+    return {
+      id: agent.id,
+      name: agent.name,
+      description: agent.description || '',
+    };
+  });
+}
+
 /**
  * Create a new full agent
  */

package/src/lib/types/agent-full.ts

@@ -28,11 +28,13 @@ import {
   type ToolInsert,
 } from '@inkeep/agents-core/client-exports';
 import type { SingleResponse } from './response';
+import type { TeamAgent } from './team-agents';
 
 // Extend FullAgentDefinition with UI-specific lookup maps
 export type FullAgentDefinition = CoreFullAgentDefinition & {
   tools?: Record<string, ToolApiInsert>;
   externalAgents?: Record<string, ExternalAgentApiInsert>;
+  teamAgents?: Record<string, TeamAgent>;
   functionTools?: Record<string, any>; // Function tools are agent-scoped
   functions?: Record<string, FunctionApiInsert>;
 };

package/src/lib/types/team-agents.ts

@@ -0,0 +1,5 @@
+export type TeamAgent = {
+  id: string; // Id of the agent that is being delegated to
+  name: string;
+  description: string;
+};

package/src/lib/utils/team-agent-utils.ts

@@ -0,0 +1,32 @@
+import type { Edge } from '@xyflow/react';
+import type { SubAgentTeamAgentConfigLookup } from '@/components/agent/agent';
+import type { TeamAgentNodeData } from '@/components/agent/configuration/node-types';
+
+/**
+ * Enhanced lookup for headers - uses relationshipId for team agents
+ * Similar to external agents but simpler since team agents are within the same project
+ */
+export function getCurrentHeadersForTeamAgentNode(
+  node: { data: TeamAgentNodeData; id: string },
+  subAgentTeamAgentConfigLookup: SubAgentTeamAgentConfigLookup,
+  _edges: Edge[]
+): Record<string, string> {
+  // First check if we have temporary headers stored on the node (from recent edits)
+  if ((node.data as any).tempHeaders !== undefined) {
+    return (node.data as any).tempHeaders;
+  }
+
+  // If node has relationshipId, find config by relationshipId
+  const relationshipId = (node.data as any).relationshipId;
+  if (relationshipId) {
+    for (const teamAgentMap of Object.values(subAgentTeamAgentConfigLookup)) {
+      const config = teamAgentMap[relationshipId];
+      if (config) {
+        return config.headers ?? {};
+      }
+    }
+  }
+
+  // No relationshipId found, return empty headers
+  return {};
+}