@inkeep/agents-manage-ui 0.26.2 → 0.27.0

package/src/components/agent/sidepane/nodes/team-agent-selector/loading.tsx

@@ -0,0 +1,26 @@
+import { Skeleton } from '@/components/ui/skeleton';
+
+interface TeamAgentSelectorLoadingProps {
+  title: string;
+}
+
+export function TeamAgentSelectorLoading({ title }: TeamAgentSelectorLoadingProps) {
+  return (
+    <div className="space-y-2">
+      <h3 className="text-sm font-medium mb-2">{title}</h3>
+      <div className="flex flex-col gap-2">
+        {[...Array(3)].map((_, index) => (
+          <div key={index} className="w-full p-3 rounded-lg border border-border">
+            <div className="flex items-start gap-3">
+              <Skeleton className="size-8 rounded flex-shrink-0" />
+              <div className="flex-1 min-w-0 space-y-2">
+                <Skeleton className="h-4 w-3/4" />
+                <Skeleton className="h-3 w-1/2" />
+              </div>
+            </div>
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}

package/src/components/agent/sidepane/nodes/team-agent-selector/team-agent-item.tsx

@@ -0,0 +1,38 @@
+import { Users } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import type { Agent } from '@/lib/types/agent-full';
+
+interface TeamAgentItemProps {
+  agent: Agent;
+  onClick: (agent: Agent) => void;
+}
+
+export function TeamAgentItem({ agent, onClick }: TeamAgentItemProps) {
+  const { id, name, description } = agent;
+
+  return (
+    <Button
+      variant="unstyled"
+      size="unstyled"
+      type="button"
+      key={id}
+      className="w-full p-3 rounded-lg border cursor-pointer transition-colors border-border hover:bg-muted/50 text-left inline-block"
+      id={id}
+      onClick={() => onClick(agent)}
+    >
+      <div className="flex items-start gap-3">
+        <div className="flex-shrink-0 mt-0.5 size-8 rounded bg-muted flex items-center justify-center">
+          <Users className="size-4 text-muted-foreground" />
+        </div>
+        <div className="flex-1 min-w-0">
+          <div className="flex items-center justify-between mb-1 gap-2 min-w-0 truncate">
+            <span className="font-medium text-sm truncate">{name}</span>
+          </div>
+          {description && (
+            <p className="text-xs text-muted-foreground truncate mb-1">{description}</p>
+          )}
+        </div>
+      </div>
+    </Button>
+  );
+}

package/src/components/agent/sidepane/nodes/team-agent-selector/team-agent-selector.tsx

@@ -0,0 +1,110 @@
+import { type Node, useReactFlow } from '@xyflow/react';
+import { useParams } from 'next/navigation';
+import { useEffect, useState } from 'react';
+import { toast } from 'sonner';
+import { fetchAgents } from '@/lib/api/agent-full-client';
+import type { Agent } from '@/lib/types/agent-full';
+import { NodeType } from '../../../configuration/node-types';
+import { EmptyState } from '../empty-state';
+import { TeamAgentSelectorLoading } from './loading';
+import { TeamAgentItem } from './team-agent-item';
+
+interface TeamAgentSelectorState {
+  agents: Agent[];
+  isLoading: boolean;
+  error: string | null;
+}
+
+const useFetchAvailableAgents = (): TeamAgentSelectorState => {
+  const [agents, setAgents] = useState<Agent[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const { tenantId, projectId, agentId } = useParams<{
+    tenantId: string;
+    projectId: string;
+    agentId: string;
+  }>();
+
+  useEffect(() => {
+    const loadAgents = async () => {
+      try {
+        setIsLoading(true);
+        setError(null);
+        const response = await fetchAgents(tenantId, projectId);
+        // Filter out the current agent to prevent self-selection
+        const filteredAgents = agentId
+          ? response.data.filter((agent) => agent.id !== agentId)
+          : response.data;
+        setAgents(filteredAgents);
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : 'Failed to load agents';
+        setError(errorMessage);
+        toast.error(errorMessage);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    loadAgents();
+  }, [tenantId, projectId, agentId]);
+
+  return { agents, isLoading, error };
+};
+
+export function TeamAgentSelector({ selectedNode }: { selectedNode: Node }) {
+  const { updateNode } = useReactFlow();
+  const { tenantId, projectId } = useParams<{
+    tenantId: string;
+    projectId: string;
+  }>();
+  const { agents, isLoading, error } = useFetchAvailableAgents();
+
+  const handleSelect = (agent: Agent) => {
+    updateNode(selectedNode.id, {
+      type: NodeType.TeamAgent,
+      data: {
+        id: agent.id,
+        name: agent.name,
+        description: agent.description,
+        relationshipId: null, // Will be set after saving to database
+      },
+    });
+  };
+
+  if (isLoading) {
+    return <TeamAgentSelectorLoading title="Select team agent" />;
+  }
+
+  if (error) {
+    return (
+      <EmptyState
+        message="Something went wrong."
+        actionText="Create agent"
+        actionHref={`/${tenantId}/projects/${projectId}/agents/new`}
+      />
+    );
+  }
+
+  if (!agents?.length) {
+    return (
+      <EmptyState
+        message="No agents found."
+        actionText="Create agent"
+        actionHref={`/${tenantId}/projects/${projectId}/agents/new`}
+      />
+    );
+  }
+
+  return (
+    <div>
+      <div className="space-y-2">
+        <h3 className="text-sm font-medium mb-2">Select team agent</h3>
+        <div className="flex flex-col gap-2 min-w-0 min-h-0">
+          {agents.map((agent: Agent) => (
+            <TeamAgentItem key={agent.id} agent={agent} onClick={handleSelect} />
+          ))}
+        </div>
+      </div>
+    </div>
+  );
+}

package/src/components/agent/sidepane/sidepane.tsx

@@ -7,7 +7,11 @@ import type { ArtifactComponent } from '@/lib/api/artifact-components';
 import type { Credential } from '@/lib/api/credentials';
 import type { DataComponent } from '@/lib/api/data-components';
 import { SidePane as SidePaneLayout } from '../../layout/sidepane';
-import type { AgentToolConfigLookup, SubAgentExternalAgentConfigLookup } from '../agent';
+import type {
+  AgentToolConfigLookup,
+  SubAgentExternalAgentConfigLookup,
+  SubAgentTeamAgentConfigLookup,
+} from '../agent';
 import { edgeTypeMap } from '../configuration/edge-types';
 import {
   type AgentNodeData,
@@ -16,6 +20,7 @@ import {
   type MCPNodeData,
   NodeType,
   nodeTypeMap,
+  type TeamAgentNodeData,
 } from '../configuration/node-types';
 import EdgeEditor from './edges/edge-editor';
 import { EditorLoadingSkeleton } from './editor-loading-skeleton';
@@ -27,6 +32,8 @@ import { FunctionToolNodeEditor } from './nodes/function-tool-node-editor';
 import { MCPServerNodeEditor } from './nodes/mcp-node-editor';
 import { MCPSelector } from './nodes/mcp-selector/mcp-selector';
 import { SubAgentNodeEditor } from './nodes/sub-agent-node-editor';
+import { TeamAgentNodeEditor } from './nodes/team-agent-node-editor';
+import { TeamAgentSelector } from './nodes/team-agent-selector/team-agent-selector';
 
 interface SidePaneProps {
   selectedNodeId: string | null;
@@ -38,6 +45,7 @@ interface SidePaneProps {
   artifactComponentLookup: Record<string, ArtifactComponent>;
   agentToolConfigLookup: AgentToolConfigLookup;
   subAgentExternalAgentConfigLookup: SubAgentExternalAgentConfigLookup;
+  subAgentTeamAgentConfigLookup: SubAgentTeamAgentConfigLookup;
   credentialLookup: Record<string, Credential>;
 }
 
@@ -51,6 +59,7 @@ export function SidePane({
   artifactComponentLookup,
   agentToolConfigLookup,
   subAgentExternalAgentConfigLookup,
+  subAgentTeamAgentConfigLookup,
   credentialLookup,
 }: SidePaneProps) {
   const selectedNode = useNodesData(selectedNodeId || '');
@@ -125,6 +134,18 @@ export function SidePane({
         case NodeType.ExternalAgentPlaceholder: {
           return <ExternalAgentSelector selectedNode={selectedNode as Node} />;
         }
+        case NodeType.TeamAgent: {
+          return (
+            <TeamAgentNodeEditor
+              selectedNode={selectedNode as Node<TeamAgentNodeData>}
+              subAgentTeamAgentConfigLookup={subAgentTeamAgentConfigLookup}
+              errorHelpers={errorHelpers}
+            />
+          );
+        }
+        case NodeType.TeamAgentPlaceholder: {
+          return <TeamAgentSelector selectedNode={selectedNode as Node} />;
+        }
         case NodeType.MCPPlaceholder: {
           return <MCPSelector selectedNode={selectedNode as Node} />;
         }
@@ -162,6 +183,7 @@ export function SidePane({
     agentToolConfigLookup,
     credentialLookup,
     subAgentExternalAgentConfigLookup,
+    subAgentTeamAgentConfigLookup,
   ]);
 
   const showBackButton = useMemo(() => {

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

@@ -1,4 +1,3 @@
-import { generateId } from '@/lib/utils/id-utils';
 import type { Edge, Node } from '@xyflow/react';
 import * as dagre from 'dagre';
 import { EdgeType } from '@/components/agent/configuration/edge-types';
@@ -9,9 +8,11 @@ import {
   functionToolNodeHandleId,
   mcpNodeHandleId,
   NodeType,
+  teamAgentNodeTargetHandleId,
 } from '@/components/agent/configuration/node-types';
 import type { FullAgentDefinition } from '@/lib/types/agent-full';
 import { formatJsonField } from '@/lib/utils';
+import { generateId } from '@/lib/utils/id-utils';
 
 interface TransformResult {
   nodes: Node[];
@@ -101,6 +102,7 @@ export function deserializeAgentData(data: FullAgentDefinition): TransformResult
   const nodes: Node[] = [];
   const edges: Edge[] = [];
   const createdExternalAgentNodes = new Set<string>();
+  const createdTeamAgentNodes = new Set<string>();
 
   const subAgentIds: string[] = Object.keys(data.subAgents);
   for (const subAgentId of subAgentIds) {
@@ -319,12 +321,14 @@ export function deserializeAgentData(data: FullAgentDefinition): TransformResult
       for (const targetSubAgent of sourceAgent.canDelegateTo) {
         let targetSubAgentId: string;
         let isTargetExternal: boolean;
+        let isTargetTeamAgent: boolean;
         let headers: Record<string, string> | undefined;
         let relationshipId: string | undefined;
 
         if (typeof targetSubAgent === 'object' && 'externalAgentId' in targetSubAgent) {
           targetSubAgentId = targetSubAgent.externalAgentId;
           isTargetExternal = true;
+          isTargetTeamAgent = false;
           headers = targetSubAgent.headers ?? undefined;
           relationshipId = targetSubAgent.subAgentExternalAgentRelationId;
 
@@ -370,12 +374,61 @@ export function deserializeAgentData(data: FullAgentDefinition): TransformResult
             },
           };
           edges.push(edge);
+        } else if (typeof targetSubAgent === 'object' && 'agentId' in targetSubAgent) {
+          // Handle team agent delegation
+          targetSubAgentId = targetSubAgent.agentId;
+          isTargetExternal = false;
+          isTargetTeamAgent = true;
+          headers = targetSubAgent.headers ?? undefined;
+          relationshipId = targetSubAgent.subAgentTeamAgentRelationId;
+
+          // Create team agent node if it doesn't exist
+          if (!createdTeamAgentNodes.has(targetSubAgentId)) {
+            const teamAgent = data.teamAgents?.[targetSubAgentId];
+            if (teamAgent) {
+              const teamAgentNode: Node = {
+                id: targetSubAgentId,
+                type: NodeType.TeamAgent,
+                position: { x: 0, y: 0 },
+                data: {
+                  id: targetSubAgentId,
+                  name: teamAgent.name,
+                  description: teamAgent.description,
+                  relationshipId,
+                  tempHeaders: headers,
+                },
+              };
+              nodes.push(teamAgentNode);
+              createdTeamAgentNodes.add(targetSubAgentId);
+            }
+          }
+
+          // Create edge from source agent to team agent
+          const edge: Edge = {
+            id: `edge-${sourceSubAgentId}-${targetSubAgentId}`,
+            type: EdgeType.A2ATeam, // Use same edge type as external agents
+            source: sourceSubAgentId,
+            sourceHandle: agentNodeSourceHandleId,
+            target: targetSubAgentId,
+            targetHandle: teamAgentNodeTargetHandleId,
+            selected: false,
+            data: {
+              relationships: {
+                transferTargetToSource: false,
+                transferSourceToTarget: false,
+                delegateTargetToSource: false,
+                delegateSourceToTarget: true,
+              },
+            },
+          };
+          edges.push(edge);
         } else {
           targetSubAgentId = targetSubAgent;
           isTargetExternal = false;
+          isTargetTeamAgent = false;
         }
 
-        if (!isTargetExternal && data.subAgents[targetSubAgentId]) {
+        if (!isTargetExternal && !isTargetTeamAgent && data.subAgents[targetSubAgentId]) {
           // Special handling for self-referencing edges
           const isSelfReference = sourceSubAgentId === targetSubAgentId;
           const pairKey = isSelfReference

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
  */