Add EntityMcpOptions support and fix schema structure

Co-authored-by: Aniruddh25 <[email protected]>

Author: Copilot

schemas/dab.draft.schema.json

@@ -695,12 +695,10 @@
     },
     "autoentities": {
       "type": "object",
-      "description": "Auto-entity definitions for pattern matching",
-      "patternProperties": {
-        "^.*$": {
-          "type": "object",
-          "additionalProperties": false,
-          "properties": {
+      "description": "Defines automatic entity generation rules for MSSQL tables based on include/exclude patterns and defaults.",
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
             "patterns": {
               "type": "object",
               "description": "Pattern matching rules for including/excluding database objects",
@@ -850,7 +848,8 @@
               "required": [ "role", "actions" ]
             }
           }
-        }
+        },
+        "required": [ "permissions" ]
       }
     },
     "entities": {

src/Config/Converters/AutoentityTemplateConverter.cs

@@ -25,6 +25,10 @@ public AutoentityTemplateConverter(DeserializationVariableReplacementSettings? r
         if (reader.TokenType is JsonTokenType.StartObject)
         {
             // Create converters for each of the sub-properties.
+            EntityMcpOptionsConverterFactory mcpOptionsConverterFactory = new();
+            JsonConverter<EntityMcpOptions> mcpOptionsConverter = (JsonConverter<EntityMcpOptions>)(mcpOptionsConverterFactory.CreateConverter(typeof(EntityMcpOptions), options)
+                ?? throw new JsonException("Unable to create converter for EntityMcpOptions"));
+
             EntityRestOptionsConverterFactory restOptionsConverterFactory = new(_replacementSettings);
             JsonConverter<EntityRestOptions> restOptionsConverter = (JsonConverter<EntityRestOptions>)(restOptionsConverterFactory.CreateConverter(typeof(EntityRestOptions), options)
                 ?? throw new JsonException("Unable to create converter for EntityRestOptions"));
@@ -42,6 +46,7 @@ public AutoentityTemplateConverter(DeserializationVariableReplacementSettings? r
                 ?? throw new JsonException("Unable to create converter for EntityCacheOptions"));
 
             // Initialize all sub-properties to null.
+            EntityMcpOptions? mcp = null;
             EntityRestOptions? rest = null;
             EntityGraphQLOptions? graphQL = null;
             EntityHealthCheckConfig? health = null;
@@ -51,14 +56,18 @@ public AutoentityTemplateConverter(DeserializationVariableReplacementSettings? r
             {
                 if (reader.TokenType == JsonTokenType.EndObject)
                 {
-                    return new AutoentityTemplate(rest, graphQL, health, cache);
+                    return new AutoentityTemplate(mcp, rest, graphQL, health, cache);
                 }
 
                 string? propertyName = reader.GetString();
 
                 reader.Read();
                 switch (propertyName)
                 {
+                    case "mcp":
+                        mcp = mcpOptionsConverter.Read(ref reader, typeof(EntityMcpOptions), options);
+                        break;
+
                     case "rest":
                         rest = restOptionsConverter.Read(ref reader, typeof(EntityRestOptions), options);
                         break;
@@ -67,10 +76,6 @@ public AutoentityTemplateConverter(DeserializationVariableReplacementSettings? r
                         graphQL = graphQLOptionsConverter.Read(ref reader, typeof(EntityGraphQLOptions), options);
                         break;
 
-                    case "mcp":
-                        // TODO: Add MCP support for autoentities needed.
-                        break;
-
                     case "health":
                         health = healthOptionsConverter.Read(ref reader, typeof(EntityHealthCheckConfig), options);
                         break;
@@ -99,6 +104,12 @@ public override void Write(Utf8JsonWriter writer, AutoentityTemplate value, Json
     {
         writer.WriteStartObject();
 
+        if (value?.UserProvidedMcpOptions is true)
+        {
+            writer.WritePropertyName("mcp");
+            JsonSerializer.Serialize(writer, value.Mcp, options);
+        }
+
         if (value?.UserProvidedRestOptions is true)
         {
             writer.WritePropertyName("rest");

src/Config/Converters/EntityMcpOptionsConverterFactory.cs

@@ -0,0 +1,123 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Azure.DataApiBuilder.Config.ObjectModel;
+
+namespace Azure.DataApiBuilder.Config.Converters;
+
+/// <summary>
+/// Factory for creating EntityMcpOptions converters.
+/// </summary>
+internal class EntityMcpOptionsConverterFactory : JsonConverterFactory
+{
+    public override bool CanConvert(Type typeToConvert)
+    {
+        return typeToConvert == typeof(EntityMcpOptions);
+    }
+
+    public override JsonConverter CreateConverter(Type typeToConvert, JsonSerializerOptions options)
+    {
+        return new EntityMcpOptionsConverter();
+    }
+
+    /// <summary>
+    /// Converter for EntityMcpOptions that handles both boolean and object representations.
+    /// When boolean: true enables dml-tools and custom-tool remains false (default), false disables dml-tools and custom-tool remains false.
+    /// When object: can specify individual properties (custom-tool and dml-tools).
+    /// </summary>
+    private class EntityMcpOptionsConverter : JsonConverter<EntityMcpOptions>
+    {
+        public override EntityMcpOptions? Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
+        {
+            if (reader.TokenType == JsonTokenType.Null)
+            {
+                return null;
+            }
+
+            // Handle boolean shorthand: true/false
+            if (reader.TokenType == JsonTokenType.True || reader.TokenType == JsonTokenType.False)
+            {
+                bool value = reader.GetBoolean();
+                // Boolean true means: dml-tools=true, custom-tool=false (default)
+                // Boolean false means: dml-tools=false, custom-tool=false
+                // Pass null for customToolEnabled to keep it as default (not user-provided)
+                return new EntityMcpOptions(
+                    customToolEnabled: null,
+                    dmlToolsEnabled: value
+                );
+            }
+
+            // Handle object representation
+            if (reader.TokenType == JsonTokenType.StartObject)
+            {
+                bool? customToolEnabled = null;
+                bool? dmlToolsEnabled = null;
+
+                while (reader.Read())
+                {
+                    if (reader.TokenType == JsonTokenType.EndObject)
+                    {
+                        return new EntityMcpOptions(customToolEnabled, dmlToolsEnabled);
+                    }
+
+                    if (reader.TokenType == JsonTokenType.PropertyName)
+                    {
+                        string? propertyName = reader.GetString();
+                        reader.Read(); // Move to the value
+
+                        switch (propertyName)
+                        {
+                            case "custom-tool":
+                                customToolEnabled = reader.GetBoolean();
+                                break;
+                            case "dml-tools":
+                                dmlToolsEnabled = reader.GetBoolean();
+                                break;
+                            default:
+                                throw new JsonException($"Unknown property '{propertyName}' in EntityMcpOptions");
+                        }
+                    }
+                }
+            }
+
+            throw new JsonException($"Unexpected token type {reader.TokenType} for EntityMcpOptions");
+        }
+
+        public override void Write(Utf8JsonWriter writer, EntityMcpOptions value, JsonSerializerOptions options)
+        {
+            if (value == null)
+            {
+                return;
+            }
+
+            // Check if we should write as boolean shorthand
+            // Write as boolean if: only dml-tools is set (or custom-tool is default false)
+            bool writeAsBoolean = !value.UserProvidedCustomToolEnabled && value.UserProvidedDmlToolsEnabled;
+
+            if (writeAsBoolean)
+            {
+                // Write as boolean shorthand
+                writer.WriteBooleanValue(value.DmlToolEnabled);
+            }
+            else if (value.UserProvidedCustomToolEnabled || value.UserProvidedDmlToolsEnabled)
+            {
+                // Write as object
+                writer.WriteStartObject();
+
+                if (value.UserProvidedCustomToolEnabled)
+                {
+                    writer.WriteBoolean("custom-tool", value.CustomToolEnabled);
+                }
+
+                if (value.UserProvidedDmlToolsEnabled)
+                {
+                    writer.WriteBoolean("dml-tools", value.DmlToolEnabled);
+                }
+
+                writer.WriteEndObject();
+            }
+        }
+    }
+}

src/Config/ObjectModel/AutoentityTemplate.cs

@@ -16,20 +16,30 @@ namespace Azure.DataApiBuilder.Config.ObjectModel;
 /// <param name="Cache">Cache configuration</param>
 public record AutoentityTemplate
 {
-    // TODO: Will add Mcp variable once MCP is supported at an entity level
-    // public EntityMcpOptions? Mcp { get; init; }
+    public EntityMcpOptions? Mcp { get; init; }
     public EntityRestOptions Rest { get; init; }
     public EntityGraphQLOptions GraphQL { get; init; }
     public EntityHealthCheckConfig Health { get; init; }
     public EntityCacheOptions Cache { get; init; }
 
     [JsonConstructor]
     public AutoentityTemplate(
+        EntityMcpOptions? Mcp = null,
         EntityRestOptions? Rest = null,
         EntityGraphQLOptions? GraphQL = null,
         EntityHealthCheckConfig? Health = null,
         EntityCacheOptions? Cache = null)
     {
+        if (Mcp is not null)
+        {
+            this.Mcp = Mcp;
+            UserProvidedMcpOptions = true;
+        }
+        else
+        {
+            this.Mcp = null;
+        }
+
         if (Rest is not null)
         {
             this.Rest = Rest;
@@ -71,6 +81,20 @@ public AutoentityTemplate(
         }
     }
 
+    /// <summary>
+    /// Flag which informs CLI and JSON serializer whether to write mcp
+    /// property and value to the runtime config file.
+    /// When user doesn't provide the mcp property/value, which signals DAB to use the default,
+    /// the DAB CLI should not write the default value to a serialized config.
+    /// This is because the user's intent is to use DAB's default value which could change
+    /// and DAB CLI writing the property and value would lose the user's intent.
+    /// This is because if the user were to use the CLI created config, a mcp
+    /// property/value specified would be interpreted by DAB as "user explicitly set mcp."
+    /// </summary>
+    [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+    [MemberNotNullWhen(true, nameof(Mcp))]
+    public bool UserProvidedMcpOptions { get; init; } = false;
+
     /// <summary>
     /// Flag which informs CLI and JSON serializer whether to write rest
     /// property and value to the runtime config file.

src/Config/ObjectModel/EntityMcpOptions.cs

@@ -0,0 +1,59 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using System.Text.Json.Serialization;
+
+namespace Azure.DataApiBuilder.Config.ObjectModel
+{
+    /// <summary>
+    /// Options for Model Context Protocol (MCP) tools at the entity level.
+    /// </summary>
+    public record EntityMcpOptions
+    {
+        /// <summary>
+        /// Indicates whether custom tools are enabled for this entity.
+        /// Only applicable for stored procedures.
+        /// </summary>
+        [JsonPropertyName("custom-tool")]
+        public bool CustomToolEnabled { get; init; } = false;
+
+        /// <summary>
+        /// Indicates whether DML tools are enabled for this entity.
+        /// Defaults to true when not explicitly provided.
+        /// </summary>
+        [JsonPropertyName("dml-tools")]
+        public bool DmlToolEnabled { get; init; } = true;
+
+        /// <summary>
+        /// Flag which informs CLI and JSON serializer whether to write the CustomToolEnabled
+        /// </summary>
+        [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+        public bool UserProvidedCustomToolEnabled { get; init; } = false;
+
+        /// <summary>
+        /// Flag which informs CLI and JSON serializer whether to write the DmlToolEnabled
+        /// </summary>
+        [JsonIgnore(Condition = JsonIgnoreCondition.Always)]
+        public bool UserProvidedDmlToolsEnabled { get; init; } = false;
+
+        /// <summary>
+        /// Constructor for EntityMcpOptions
+        /// </summary>
+        /// <param name="customToolEnabled">The custom tool enabled flag.</param>
+        /// <param name="dmlToolsEnabled">The DML tools enabled flag.</param>
+        public EntityMcpOptions(bool? customToolEnabled, bool? dmlToolsEnabled)
+        {
+            if (customToolEnabled.HasValue)
+            {
+                this.CustomToolEnabled = customToolEnabled.Value;
+                this.UserProvidedCustomToolEnabled = true;
+            }
+
+            if (dmlToolsEnabled.HasValue)
+            {
+                this.DmlToolEnabled = dmlToolsEnabled.Value;
+                this.UserProvidedDmlToolsEnabled = true;
+            }
+        }
+    }
+}

src/Config/RuntimeConfigLoader.cs

@@ -311,6 +311,7 @@ public static JsonSerializerOptions GetSerializationOptions(
         options.Converters.Add(new EntitySourceConverterFactory(replacementSettings));
         options.Converters.Add(new EntityGraphQLOptionsConverterFactory(replacementSettings));
         options.Converters.Add(new EntityRestOptionsConverterFactory(replacementSettings));
+        options.Converters.Add(new EntityMcpOptionsConverterFactory());
         options.Converters.Add(new EntityActionConverterFactory());
         options.Converters.Add(new DataSourceFilesConverter());
         options.Converters.Add(new EntityCacheOptionsConverterFactory(replacementSettings));

src/Service.Tests/Caching/DabCacheServiceIntegrationTests.cs

@@ -759,14 +759,15 @@ private static Mock<RuntimeConfigProvider> CreateMockRuntimeConfigProvider(strin
                 { entityName, entity }
             });
 
+            // Schema, DataSource, Entities, Autoentities, Runtime, DataSourceFiles, AzureKeyVault
             Mock<RuntimeConfig> mockRuntimeConfig = new(
-                string.Empty,
-                dataSource,
-                entities,
-                null,
-                null,
-                null,
-                null
+                string.Empty,         // Schema
+                dataSource,          // DataSource
+                entities,            // Entities
+                null,                // Autoentities
+                null,                // Runtime
+                null,                // DataSourceFiles
+                null                 // AzureKeyVault
             );
             mockRuntimeConfig
                 .Setup(c => c.GetDataSourceFromDataSourceName(It.IsAny<string>()))