d365fo-client 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

d365fo_client/mcp/mixins/base_tools_mixin.py

@@ -1,7 +1,6 @@
 """Base mixin class for FastMCP tool categories."""
 
 import logging
-from typing import Optional
 
 from d365fo_client.client import FOClient
 from d365fo_client.profile_manager import ProfileManager
@@ -13,30 +12,32 @@ logger = logging.getLogger(__name__)
 
 class BaseToolsMixin:
     """Base mixin for FastMCP tool categories.
-    
+
     Provides common functionality and client access patterns
     for all tool category mixins.
     """
-    
+
     # These will be injected by the main server class
     client_manager: D365FOClientManager
-    mcp: FastMCP  
-    profile_manager:  ProfileManager
-    
+    mcp: FastMCP
+    profile_manager: ProfileManager
+
     async def _get_client(self, profile: str = "default") -> FOClient:
         """Get D365FO client for specified profile.
-        
+
         Args:
             profile: Profile name to use
-            
+
         Returns:
             Configured D365FO client instance
         """
-        if not hasattr(self, 'client_manager') or not self.client_manager:
+        if not hasattr(self, "client_manager") or not self.client_manager:
             raise RuntimeError("Client manager not initialized")
         return await self.client_manager.get_client(profile)
-    
-    def _create_error_response(self, error: Exception, tool_name: str, arguments: dict) -> dict:
+
+    def _create_error_response(
+        self, error: Exception, tool_name: str, arguments: dict
+    ) -> dict:
         """Create standardized error response.
 
         Args:
@@ -52,4 +53,4 @@ class BaseToolsMixin:
             "tool": tool_name,
             "arguments": arguments,
             "error_type": type(error).__name__,
-        }
+        }

d365fo_client/mcp/mixins/crud_tools_mixin.py

@@ -10,10 +10,10 @@ logger = logging.getLogger(__name__)
 
 class CrudToolsMixin(BaseToolsMixin):
     """CRUD (Create, Read, Update, Delete) tools for FastMCP server."""
-    
+
     def register_crud_tools(self):
         """Register all CRUD tools with FastMCP."""
-        
+
         @self.mcp.tool()
         async def d365fo_query_entities(
             entity_name: str,
@@ -67,7 +67,7 @@ class CrudToolsMixin(BaseToolsMixin):
                     expand=expand,
                 )
 
-                # Execute query
+                # FOClient now handles validation and schema fetching
                 result = await client.get_entities(entity_name, options=options)
 
                 return {
@@ -109,6 +109,18 @@ class CrudToolsMixin(BaseToolsMixin):
                 Dictionary with the entity record
             """
             try:
+                # Validate key_fields and key_values match
+                if len(key_fields) != len(key_values):
+                    return {
+                        "error": "Key fields and values length mismatch",
+                        "entityName": entity_name,
+                        "key_fields": key_fields,
+                        "key_values": key_values,
+                    }
+
+                # Build key dict
+                key = {k: v for k, v in zip(key_fields, key_values)}
+
                 client = await self._get_client(profile)
 
                 # Build query options
@@ -120,19 +132,32 @@ class CrudToolsMixin(BaseToolsMixin):
                     else None
                 )
 
-                # Construct key field=value mapping
-                if len(key_fields) != len(key_values):
-                    raise ValueError("Key fields and values length mismatch")
-                key = {k: v for k, v in zip(key_fields, key_values)}
-
-                # Get entity record
-                result = await client.get_entity_by_key(entity_name, key, options)  # type: ignore
+                # FOClient now handles:
+                # - Schema lookup via get_public_entity_schema_by_entityset()
+                # - Entity validation (raises FOClientError if not found)
+                # - Schema-aware key encoding via QueryBuilder
+                result = await client.get_entity(entity_name, key, options)
 
                 return {"entityName": entity_name, "key": key, "data": result}
 
             except Exception as e:
                 logger.error(f"Get entity record failed: {e}")
-                return {"error": str(e), "entityName": entity_name, "key_fields": key_fields, "key_values": key_values, "key": key}
+                # Build key dict for error response if possible
+                try:
+                    key = (
+                        {k: v for k, v in zip(key_fields, key_values)}
+                        if len(key_fields) == len(key_values)
+                        else None
+                    )
+                except Exception:
+                    key = None
+                return {
+                    "error": str(e),
+                    "entityName": entity_name,
+                    "key_fields": key_fields,
+                    "key_values": key_values,
+                    "key": key,
+                }
 
         @self.mcp.tool()
         async def d365fo_create_entity_record(
@@ -155,10 +180,12 @@ class CrudToolsMixin(BaseToolsMixin):
             try:
                 client = await self._get_client(profile)
 
-                # Create entity record
-                result = await client.create_entity(
-                    entity_name, data
-                )
+                # FOClient now handles:
+                # - Schema validation via get_public_entity_schema_by_entityset()
+                # - Entity existence check (raises FOClientError if not found)
+                # - Read-only validation (raises FOClientError if read-only)
+                # - OData serialization via crud_ops
+                result = await client.create_entity(entity_name, data)
 
                 return {
                     "entityName": entity_name,
@@ -193,18 +220,27 @@ class CrudToolsMixin(BaseToolsMixin):
                 Dictionary with update result
             """
             try:
-                client = await self._get_client(profile)
-
-                # Construct key field=value mapping
+                # Validate key_fields and key_values match
                 if len(key_fields) != len(key_values):
-                    raise ValueError("Key fields and values length mismatch")
-
+                    return {
+                        "error": "Key fields and values length mismatch",
+                        "entityName": entity_name,
+                        "key_fields": key_fields,
+                        "key_values": key_values,
+                        "updated": False,
+                    }
+
+                # Build key dict
                 key = {k: v for k, v in zip(key_fields, key_values)}
 
-                # Update entity record
-                result = await client.update_entity(
-                    entity_name, key, data
-                )
+                client = await self._get_client(profile)
+
+                # FOClient now handles:
+                # - Schema validation via get_public_entity_schema_by_entityset()
+                # - Entity existence check (raises FOClientError if not found)
+                # - Read-only validation (raises FOClientError if read-only)
+                # - Schema-aware key encoding via QueryBuilder
+                result = await client.update_entity(entity_name, key, data)
 
                 return {
                     "entityName": entity_name,
@@ -215,10 +251,19 @@ class CrudToolsMixin(BaseToolsMixin):
 
             except Exception as e:
                 logger.error(f"Update entity record failed: {e}")
+                # Build key dict for error response if possible
+                try:
+                    key = (
+                        {k: v for k, v in zip(key_fields, key_values)}
+                        if len(key_fields) == len(key_values)
+                        else None
+                    )
+                except Exception:
+                    key = None
                 return {
                     "error": str(e),
                     "entityName": entity_name,
-                    "key": key, # type: ignore
+                    "key": key,
                     "updated": False,
                 }
 
@@ -227,7 +272,7 @@ class CrudToolsMixin(BaseToolsMixin):
             entity_name: str,
             key_fields: List[str],
             key_values: List[str],
-            profile: str = "default"
+            profile: str = "default",
         ) -> dict:
             """Delete a record from a D365 Finance & Operations data entity.
 
@@ -241,35 +286,55 @@ class CrudToolsMixin(BaseToolsMixin):
                 Dictionary with deletion result
             """
             try:
-                client = await self._get_client(profile)
-
-                # Construct key field=value mapping
+                # Validate key_fields and key_values match
                 if len(key_fields) != len(key_values):
-                    raise ValueError("Key fields and values length mismatch")
-
+                    return {
+                        "error": "Key fields and values length mismatch",
+                        "entityName": entity_name,
+                        "key_fields": key_fields,
+                        "key_values": key_values,
+                        "deleted": False,
+                    }
+
+                # Build key dict
                 key = {k: v for k, v in zip(key_fields, key_values)}
 
-                # Delete entity record
+                client = await self._get_client(profile)
+
+                # FOClient now handles:
+                # - Schema validation via get_public_entity_schema_by_entityset()
+                # - Entity existence check (raises FOClientError if not found)
+                # - Read-only validation (raises FOClientError if read-only)
+                # - Schema-aware key encoding via QueryBuilder
                 await client.delete_entity(entity_name, key)
 
                 return {"entityName": entity_name, "key": key, "deleted": True}
 
             except Exception as e:
                 logger.error(f"Delete entity record failed: {e}")
+                # Build key dict for error response if possible
+                try:
+                    key = (
+                        {k: v for k, v in zip(key_fields, key_values)}
+                        if len(key_fields) == len(key_values)
+                        else None
+                    )
+                except Exception:
+                    key = None
                 return {
                     "error": str(e),
                     "entityName": entity_name,
-                    "key": key, # type: ignore
+                    "key": key,
                     "deleted": False,
                 }
 
         @self.mcp.tool()
         async def d365fo_call_action(
             action_name: str,
-            entity_name: str = None,# type: ignore
-            parameters: dict = None,# type: ignore
-            key_fields: List[str] = None,# type: ignore
-            key_values: List[str] = None,# type: ignore
+            entity_name: str = None,  # type: ignore
+            parameters: dict = None,  # type: ignore
+            key_fields: List[str] = None,  # type: ignore
+            key_values: List[str] = None,  # type: ignore
             profile: str = "default",
         ) -> dict:
             """Execute an OData action method in D365 Finance & Operations.
@@ -297,15 +362,91 @@ class CrudToolsMixin(BaseToolsMixin):
                     key = {k: v for k, v in zip(key_fields, key_values)}
 
                 result = await client.call_action(
-                    action_name=action_name,# type: ignore
+                    action_name=action_name,  # type: ignore
                     parameters=parameters or {},
                     entity_name=entity_name,
                     entity_key=key,
-                    
                 )
 
                 return {"actionName": action_name, "success": True, "result": result}
 
             except Exception as e:
                 logger.error(f"Call action failed: {e}")
-                return {"error": str(e), "actionName": action_name, "success": False}
+                return {"error": str(e), "actionName": action_name, "success": False}
+
+        @self.mcp.tool()
+        async def d365fo_call_json_service(
+            service_group: str,
+            service_name: str,
+            operation_name: str,
+            parameters: Optional[dict] = None,
+            profile: str = "default",
+        ) -> dict:
+            """Call a D365 F&O JSON service endpoint using the /api/services pattern.
+
+            This provides a generic way to invoke any JSON service operation in D365 F&O.
+
+            Args:
+                service_group: Service group name (e.g., 'SysSqlDiagnosticService')
+                service_name: Service name (e.g., 'SysSqlDiagnosticServiceOperations')
+                operation_name: Operation name (e.g., 'GetAxSqlExecuting')
+                parameters: Optional parameters to send in the POST body
+                profile: Configuration profile to use
+
+            Returns:
+                Dictionary with service response data and metadata
+
+            Example:
+                Call a service without parameters:
+                {
+                    "service_group": "SysSqlDiagnosticService",
+                    "service_name": "SysSqlDiagnosticServiceOperations",
+                    "operation_name": "GetAxSqlExecuting"
+                }
+
+                Call a service with parameters:
+                {
+                    "service_group": "SysSqlDiagnosticService",
+                    "service_name": "SysSqlDiagnosticServiceOperations",
+                    "operation_name": "GetAxSqlResourceStats",
+                    "parameters": {
+                        "start": "2023-01-01T00:00:00Z",
+                        "end": "2023-01-02T00:00:00Z"
+                    }
+                }
+            """
+            try:
+                client = await self._get_client(profile)
+
+                # Call the JSON service
+                response = await client.post_json_service(
+                    service_group=service_group,
+                    service_name=service_name,
+                    operation_name=operation_name,
+                    parameters=parameters,
+                )
+
+                # Format response
+                result = {
+                    "success": response.success,
+                    "statusCode": response.status_code,
+                    "data": response.data,
+                    "serviceGroup": service_group,
+                    "serviceName": service_name,
+                    "operationName": operation_name,
+                }
+
+                if response.error_message:
+                    result["errorMessage"] = response.error_message
+
+                return result
+
+            except Exception as e:
+                logger.error(f"JSON service call failed: {e}")
+                return {
+                    "success": False,
+                    "error": str(e),
+                    "serviceGroup": service_group,
+                    "serviceName": service_name,
+                    "operationName": operation_name,
+                }

d365fo_client/mcp/server.py

@@ -25,7 +25,7 @@ from .resources import (
     MetadataResourceHandler,
     QueryResourceHandler,
 )
-from .tools import ConnectionTools, CrudTools, DatabaseTools, LabelTools, MetadataTools, ProfileTools, SyncTools
+from .tools import ConnectionTools, CrudTools, DatabaseTools, JsonServiceTools, LabelTools, MetadataTools, ProfileTools, SyncTools
 
 logger = logging.getLogger(__name__)
 
@@ -59,6 +59,7 @@ class D365FOMCPServer:
         self.profile_tools = ProfileTools(self.client_manager)
         self.database_tools = DatabaseTools(self.client_manager)
         self.sync_tools = SyncTools(self.client_manager)
+        self.json_service_tools = JsonServiceTools(self.client_manager)
 
         # Tool registry for execution
         self.tool_registry = {}
@@ -222,6 +223,10 @@ class D365FOMCPServer:
                 sync_tools = self.sync_tools.get_tools()
                 tools.extend(sync_tools)
 
+                # Add JSON service tools
+                json_service_tools = self.json_service_tools.get_tools()
+                tools.extend(json_service_tools)
+
                 # Register tools for execution
                 for tool in tools:
                     self.tool_registry[tool.name] = tool
@@ -327,6 +332,10 @@ class D365FOMCPServer:
                     return await self.sync_tools.execute_list_sync_sessions(arguments)
                 elif name == "d365fo_get_sync_history":
                     return await self.sync_tools.execute_get_sync_history(arguments)
+                elif name == "d365fo_call_json_service":
+                    return await self.json_service_tools.execute_call_json_service(arguments)
+                elif name == "d365fo_call_sql_diagnostic_service":
+                    return await self.json_service_tools.execute_call_sql_diagnostic_service(arguments)
                 else:
                     raise ValueError(f"Unknown tool: {name}")
 

d365fo_client/mcp/tools/__init__.py

@@ -3,6 +3,7 @@
 from .connection_tools import ConnectionTools
 from .crud_tools import CrudTools
 from .database_tools import DatabaseTools
+from .json_service_tools import JsonServiceTools
 from .label_tools import LabelTools
 from .metadata_tools import MetadataTools
 from .profile_tools import ProfileTools
@@ -16,4 +17,5 @@ __all__ = [
     "ProfileTools",
     "DatabaseTools",
     "SyncTools",
+    "JsonServiceTools",
 ]