d365fo-client 0.1.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

d365fo_client/mcp/server.py

@@ -7,6 +7,9 @@ from typing import Any, Dict, List, Optional
 
 from mcp import GetPromptResult, Resource, Tool
 from mcp.server import InitializationOptions, Server
+
+from .. import __version__
+from ..profile_manager import ProfileManager
 from mcp.server.lowlevel.server import NotificationOptions
 from mcp.types import Prompt, PromptArgument, PromptMessage, TextContent
 
@@ -36,7 +39,8 @@ class D365FOMCPServer:
         """
         self.config = config or self._load_default_config()
         self.server = Server("d365fo-mcp-server")
-        self.client_manager = D365FOClientManager(self.config)
+        self.profile_manager = ProfileManager()
+        self.client_manager = D365FOClientManager(self.config, self.profile_manager)
 
         # Initialize resource handlers
         self.entity_handler = EntityResourceHandler(self.client_manager)
@@ -321,10 +325,10 @@ class D365FOMCPServer:
             transport_type: Transport type (stdio, sse, etc.)
         """
         try:
-            logger.info("Starting D365FO MCP Server...")
+            logger.info(f"Starting D365FO MCP Server v{__version__}...")
 
-            # Perform health checks
-            await self._startup_health_checks()
+            # Perform conditional startup initialization
+            await self._startup_initialization()
 
             if transport_type == "stdio":
                 from mcp.server.stdio import stdio_server
@@ -335,7 +339,7 @@ class D365FOMCPServer:
                         write_stream,
                         InitializationOptions(
                             server_name="d365fo-mcp-server",
-                            server_version="1.0.0",
+                            server_version=__version__,
                             capabilities=self.server.get_capabilities(
                                 notification_options=NotificationOptions(),
                                 experimental_capabilities={},
@@ -351,6 +355,87 @@ class D365FOMCPServer:
         finally:
             await self.cleanup()
 
+    async def _startup_initialization(self):
+        """Perform startup initialization based on configuration."""
+        try:
+            # Check if D365FO_BASE_URL is configured
+            has_base_url = self.config.get("has_base_url", False)
+            
+            if has_base_url:
+                logger.info("D365FO_BASE_URL environment variable detected - performing health checks and profile setup")
+                
+                # Perform health checks
+                await self._startup_health_checks()
+                
+                # Create default profile if environment variables are configured
+                await self._create_default_profile_if_needed()
+            else:
+                logger.info("D365FO_BASE_URL not configured - server started in profile-only mode")
+                logger.info("Use profile management tools to configure D365FO connections")
+
+        except Exception as e:
+            logger.error(f"Startup initialization failed: {e}")
+            # Don't fail startup on initialization failures
+
+    async def _create_default_profile_if_needed(self):
+        """Create a default profile from environment variables if needed."""
+        try:
+            # Check if default profile already exists
+            existing_default = self.profile_manager.get_default_profile()
+            if existing_default:
+                logger.info(f"Default profile already exists: {existing_default.name}")
+                return
+
+            # Get environment variables
+            base_url = os.getenv("D365FO_BASE_URL")
+            client_id = os.getenv("AZURE_CLIENT_ID")
+            client_secret = os.getenv("AZURE_CLIENT_SECRET")
+            tenant_id = os.getenv("AZURE_TENANT_ID")
+
+            if not base_url:
+                logger.warning("Cannot create default profile - D365FO_BASE_URL not set")
+                return
+
+            # Determine authentication mode
+            auth_mode = "default"
+            if client_id and client_secret and tenant_id:
+                auth_mode = "client_credentials"
+
+            # Create default profile with unique name
+            profile_name = "default-from-env"
+            
+            # Check if profile with this name already exists
+            existing_profile = self.profile_manager.get_profile(profile_name)
+            if existing_profile:
+                logger.info(f"Profile '{profile_name}' already exists, setting as default")
+                self.profile_manager.set_default_profile(profile_name)
+                return
+
+            success = self.profile_manager.create_profile(
+                name=profile_name,
+                base_url=base_url,
+                auth_mode=auth_mode,
+                client_id=client_id,
+                client_secret=client_secret,
+                tenant_id=tenant_id,
+                description="Auto-created from environment variables at startup",
+                use_label_cache=True,
+                timeout=60,
+                verify_ssl=True
+            )
+
+            if success:
+                # Set as default profile
+                self.profile_manager.set_default_profile(profile_name)
+                logger.info(f"Created and set default profile: {profile_name}")
+                logger.info(f"Profile configured for: {base_url}")
+                logger.info(f"Authentication mode: {auth_mode}")
+            else:
+                logger.warning(f"Failed to create default profile: {profile_name}")
+
+        except Exception as e:
+            logger.error(f"Error creating default profile: {e}")
+
     async def _startup_health_checks(self):
         """Perform startup health checks."""
         try:

d365fo_client/mcp/tools/connection_tools.py

@@ -8,6 +8,7 @@ from typing import List
 from mcp import Tool
 from mcp.types import TextContent
 
+from ... import __version__
 from ..client_manager import D365FOClientManager
 
 logger = logging.getLogger(__name__)
@@ -95,6 +96,7 @@ class ConnectionTools:
             response = {
                 "success": success,
                 "profile": profile,
+                "clientVersion": __version__,
                 "endpoints": {
                     "data": success,
                     "metadata": success,  # Simplification for now
@@ -113,6 +115,7 @@ class ConnectionTools:
             error_response = {
                 "success": False,
                 "profile": arguments.get("profile", "default"),
+                "clientVersion": __version__,
                 "endpoints": {"data": False, "metadata": False},
                 "responseTime": 0.0,
                 "error": str(e),
@@ -124,6 +127,7 @@ class ConnectionTools:
             error_response = {
                 "success": False,
                 "profile": arguments.get("profile", "default"),
+                "clientVersion": __version__,
                 "endpoints": {"data": False, "metadata": False},
                 "responseTime": 0.0,
                 "error": str(e),
@@ -146,6 +150,7 @@ class ConnectionTools:
             # Format response according to specification with enhanced metadata info
             response = {
                 "baseUrl": env_info["base_url"],
+                "clientVersion": __version__,
                 "versions": env_info["versions"],
                 "connectivity": env_info["connectivity"],
                 "metadataInfo": env_info["metadata_info"],
@@ -160,6 +165,7 @@ class ConnectionTools:
             )
             error_response = {
                 "error": str(e),
+                "clientVersion": __version__,
                 "tool": "d365fo_get_environment_info",
                 "arguments": arguments,
                 "suggestion": "Please create a profile or set a default profile using the profile management tools.",
@@ -169,6 +175,7 @@ class ConnectionTools:
             logger.error(f"Get environment info failed: {e}")
             error_response = {
                 "error": str(e),
+                "clientVersion": __version__,
                 "tool": "d365fo_get_environment_info",
                 "arguments": arguments,
             }

d365fo_client/mcp/tools/profile_tools.py

@@ -423,6 +423,12 @@ class ProfileTools:
             if set_as_default:
                 self.profile_manager.set_default_profile(name)
 
+            # Refresh the client manager to pick up the new profile
+            await self.client_manager.refresh_profile(name)
+            if set_as_default:
+                # If setting as default, also refresh the default profile
+                await self.client_manager.refresh_profile("default")
+
             response = {
                 "success": True,
                 "profileName": name,
@@ -485,6 +491,9 @@ class ProfileTools:
                     TextContent(type="text", text=json.dumps(error_response, indent=2))
                 ]
 
+            # Refresh the client manager to pick up the updated profile
+            await self.client_manager.refresh_profile(name)
+
             response = {
                 "success": True,
                 "profileName": name,
@@ -525,6 +534,9 @@ class ProfileTools:
                     TextContent(type="text", text=json.dumps(error_response, indent=2))
                 ]
 
+            # Refresh the client manager to remove the deleted profile
+            await self.client_manager.refresh_profile(profile_name)
+
             response = {
                 "success": True,
                 "profileName": profile_name,
@@ -564,6 +576,9 @@ class ProfileTools:
                     TextContent(type="text", text=json.dumps(error_response, indent=2))
                 ]
 
+            # Refresh the default profile in client manager
+            await self.client_manager.refresh_profile("default")
+
             response = {
                 "success": True,
                 "profileName": profile_name,

d365fo_client/metadata_api.py

@@ -8,19 +8,25 @@ from d365fo_client.crud import CrudOperations
 
 from .labels import LabelOperations
 from .models import (
+    ActionInfo,
     ActionParameterInfo,
     ActionParameterTypeInfo,
     ActionReturnTypeInfo,
+    Cardinality,
     DataEntityInfo,
+    EntityCategory,
     EnumerationInfo,
     EnumerationMemberInfo,
+    FixedConstraintInfo,
     NavigationPropertyInfo,
+    ODataBindingKind,
     PropertyGroupInfo,
     PublicEntityActionInfo,
     PublicEntityInfo,
     PublicEntityPropertyInfo,
     QueryOptions,
     ReferentialConstraintInfo,
+    RelatedFixedConstraintInfo,
 )
 from .query import QueryBuilder
 from .session import SessionManager
@@ -97,26 +103,57 @@ class MetadataAPIOperations:
 
         # Process navigation properties
         for nav_data in item.get("NavigationProperties", []):
+            # Convert cardinality string to enum
+            cardinality_str = nav_data.get("Cardinality", "Single")
+            try:
+                if cardinality_str == "Single":
+                    cardinality = Cardinality.SINGLE
+                elif cardinality_str == "Multiple":
+                    cardinality = Cardinality.MULTIPLE
+                else:
+                    cardinality = Cardinality.SINGLE  # Default
+            except Exception:
+                cardinality = Cardinality.SINGLE
+                
             nav_prop = NavigationPropertyInfo(
                 name=nav_data.get("Name", ""),
                 related_entity=nav_data.get("RelatedEntity", ""),
                 related_relation_name=nav_data.get("RelatedRelationName"),
-                cardinality=nav_data.get("Cardinality", "Single"),
+                cardinality=cardinality,
             )
 
             # Process constraints
             for constraint_data in nav_data.get("Constraints", []):
-                # Check for ReferentialConstraint type (most common)
                 odata_type = constraint_data.get("@odata.type", "")
+                
                 if "ReferentialConstraint" in odata_type:
+                    # Referential constraint (foreign key relationship)
                     constraint = ReferentialConstraintInfo(
-                        constraint_type="Referential",
                         property=constraint_data.get("Property", ""),
                         referenced_property=constraint_data.get(
                             "ReferencedProperty", ""
                         ),
                     )
                     nav_prop.constraints.append(constraint)
+                    
+                elif "RelatedFixedConstraint" in odata_type:
+                    # Related fixed constraint (check this before FixedConstraint)
+                    constraint = RelatedFixedConstraintInfo(
+                        related_property=constraint_data.get("RelatedProperty", ""),
+                        value=constraint_data.get("Value"),
+                        value_str=constraint_data.get("ValueStr", constraint_data.get("StringValue")),
+                    )
+                    nav_prop.constraints.append(constraint)
+                    
+                elif "FixedConstraint" in odata_type:
+                    # Fixed value constraint
+                    constraint = FixedConstraintInfo(
+                        property=constraint_data.get("Property", ""),
+                        value=constraint_data.get("Value"),
+                        value_str=constraint_data.get("ValueStr", constraint_data.get("StringValue")),
+                    )
+                    nav_prop.constraints.append(constraint)
+                    nav_prop.constraints.append(constraint)
 
             entity.navigation_properties.append(nav_prop)
 
@@ -130,9 +167,25 @@ class MetadataAPIOperations:
 
         # Process actions
         for action_data in item.get("Actions", []):
+            # Convert binding kind string to enum
+            binding_kind_str = action_data.get("BindingKind", "BoundToEntitySet")
+            try:
+                # Try to map the string to the enum
+                if binding_kind_str == "BoundToEntityInstance":
+                    binding_kind = ODataBindingKind.BOUND_TO_ENTITY_INSTANCE
+                elif binding_kind_str == "BoundToEntitySet":
+                    binding_kind = ODataBindingKind.BOUND_TO_ENTITY_SET
+                elif binding_kind_str == "Unbound":
+                    binding_kind = ODataBindingKind.UNBOUND
+                else:
+                    # Default to BoundToEntitySet if unknown
+                    binding_kind = ODataBindingKind.BOUND_TO_ENTITY_SET
+            except Exception:
+                binding_kind = ODataBindingKind.BOUND_TO_ENTITY_SET
+                
             action = PublicEntityActionInfo(
                 name=action_data.get("Name", ""),
-                binding_kind=action_data.get("BindingKind", ""),
+                binding_kind=binding_kind,
                 field_lookup=action_data.get("FieldLookup"),
             )
 
@@ -266,6 +319,28 @@ class MetadataAPIOperations:
 
         entities = []
         for item in data.get("value", []):
+            # Convert entity category string to enum
+            entity_category_str = item.get("EntityCategory")
+            entity_category = None
+            if entity_category_str:
+                try:
+                    # Try to map the string to the enum
+                    if entity_category_str == "Master":
+                        entity_category = EntityCategory.MASTER
+                    elif entity_category_str == "Transaction":
+                        entity_category = EntityCategory.TRANSACTION
+                    elif entity_category_str == "Configuration":
+                        entity_category = EntityCategory.CONFIGURATION
+                    elif entity_category_str == "Reference":
+                        entity_category = EntityCategory.REFERENCE
+                    elif entity_category_str == "Document":
+                        entity_category = EntityCategory.DOCUMENT
+                    elif entity_category_str == "Parameters":
+                        entity_category = EntityCategory.PARAMETERS
+                    # If no match, leave as None
+                except Exception:
+                    entity_category = None
+            
             entity = DataEntityInfo(
                 name=item.get("Name", ""),
                 public_entity_name=item.get("PublicEntityName", ""),
@@ -273,7 +348,7 @@ class MetadataAPIOperations:
                 label_id=item.get("LabelId"),
                 data_service_enabled=item.get("DataServiceEnabled", False),
                 data_management_enabled=item.get("DataManagementEnabled", False),
-                entity_category=item.get("EntityCategory"),
+                entity_category=entity_category,
                 is_read_only=item.get("IsReadOnly", False),
             )
             entities.append(entity)
@@ -305,6 +380,29 @@ class MetadataAPIOperations:
             async with session.get(url) as response:
                 if response.status == 200:
                     item = await response.json()
+                    
+                    # Convert entity category string to enum
+                    entity_category_str = item.get("EntityCategory")
+                    entity_category = None
+                    if entity_category_str:
+                        try:
+                            # Try to map the string to the enum
+                            if entity_category_str == "Master":
+                                entity_category = EntityCategory.MASTER
+                            elif entity_category_str == "Transaction":
+                                entity_category = EntityCategory.TRANSACTION
+                            elif entity_category_str == "Configuration":
+                                entity_category = EntityCategory.CONFIGURATION
+                            elif entity_category_str == "Reference":
+                                entity_category = EntityCategory.REFERENCE
+                            elif entity_category_str == "Document":
+                                entity_category = EntityCategory.DOCUMENT
+                            elif entity_category_str == "Parameters":
+                                entity_category = EntityCategory.PARAMETERS
+                            # If no match, leave as None
+                        except Exception:
+                            entity_category = None
+                    
                     entity = DataEntityInfo(
                         name=item.get("Name", ""),
                         public_entity_name=item.get("PublicEntityName", ""),
@@ -314,7 +412,7 @@ class MetadataAPIOperations:
                         data_management_enabled=item.get(
                             "DataManagementEnabled", False
                         ),
-                        entity_category=item.get("EntityCategory"),
+                        entity_category=entity_category,
                         is_read_only=item.get("IsReadOnly", False),
                     )
 
@@ -791,3 +889,122 @@ class MetadataAPIOperations:
         except Exception as e:
             logger.error(f"Failed to get installed modules: {e}")
             raise
+
+    # Action Operations
+
+    async def search_actions(
+        self,
+        pattern: str = "",
+        entity_name: Optional[str] = None,
+        binding_kind: Optional[str] = None,
+    ) -> List["ActionInfo"]:
+        """Search actions across all public entities
+
+        Args:
+            pattern: Search pattern for action name (regex supported)
+            entity_name: Filter actions that are bound to a specific entity
+            binding_kind: Filter by binding type (Unbound, BoundToEntitySet, BoundToEntityInstance)
+
+        Returns:
+            List of ActionInfo objects with full details
+        """
+        from .models import ActionInfo
+
+        actions = []
+        
+        try:
+            # Compile regex pattern if provided
+            regex_pattern = None
+            if pattern:
+                try:
+                    regex_pattern = re.compile(pattern, re.IGNORECASE)
+                except re.error:
+                    # If regex is invalid, treat as literal string
+                    pattern_lower = pattern.lower()
+                    regex_pattern = lambda x: pattern_lower in x.lower()
+                else:
+                    regex_pattern = regex_pattern.search
+
+            # Get all public entities with full details
+            entities = await self.get_all_public_entities_with_details(resolve_labels=False)
+
+            for entity in entities:
+                # Filter by entity name if specified
+                if entity_name and entity.name != entity_name:
+                    continue
+
+                # Process all actions in this entity
+                for action in entity.actions:
+                    # Filter by action name pattern
+                    if regex_pattern and not regex_pattern(action.name):
+                        continue
+
+                    # Filter by binding kind
+                    if binding_kind and action.binding_kind != binding_kind:
+                        continue
+
+                    # Create ActionInfo with entity context
+                    action_info = ActionInfo(
+                        name=action.name,
+                        binding_kind=action.binding_kind,
+                        entity_name=entity.name,  # public entity name
+                        entity_set_name=entity.entity_set_name,  # entity set name for OData URLs
+                        parameters=action.parameters,
+                        return_type=action.return_type,
+                        field_lookup=action.field_lookup,
+                    )
+                    actions.append(action_info)
+
+        except Exception as e:
+            logger.error(f"Failed to search actions: {e}")
+            # Return empty list on error rather than raising
+            return []
+
+        return actions
+
+    async def get_action_info(
+        self,
+        action_name: str,
+        entity_name: Optional[str] = None,
+    ) -> Optional["ActionInfo"]:
+        """Get detailed information about a specific action
+
+        Args:
+            action_name: Name of the action
+            entity_name: Optional entity name for bound actions
+
+        Returns:
+            ActionInfo object or None if not found
+        """
+        from .models import ActionInfo
+
+        try:
+            if entity_name:
+                # If entity name is provided, get that specific entity
+                entity = await self.get_public_entity_info(entity_name, resolve_labels=False)
+                if not entity:
+                    return None
+
+                # Find the action in this entity
+                for action in entity.actions:
+                    if action.name == action_name:
+                        return ActionInfo(
+                            name=action.name,
+                            binding_kind=action.binding_kind,
+                            entity_name=entity.name,
+                            entity_set_name=entity.entity_set_name,
+                            parameters=action.parameters,
+                            return_type=action.return_type,
+                            field_lookup=action.field_lookup,
+                        )
+            else:
+                # Search across all entities for the action
+                actions = await self.search_actions(pattern=f"^{re.escape(action_name)}$")
+                if actions:
+                    # Return the first match (actions should be unique across entities)
+                    return actions[0]
+
+        except Exception as e:
+            logger.error(f"Failed to get action info for '{action_name}': {e}")
+
+        return None