@@ -14,12 +14,26 @@ namespace Microsoft.SemanticKernel;
 /// </summary>
 internal static class XmlPromptParser
 {
+    /// <summary>
+    /// Maximum element nesting depth supported in an XML prompt, where top-level prompt elements are at depth 1.
+    /// </summary>
+    /// <remarks>
+    /// Chat prompts only need a shallow structure, such as message elements that contain content elements.
+    /// Each <see cref="PromptNode"/> stores the serialized content of its whole subtree, so the parsing work
+    /// grows with the nesting depth multiplied by the prompt size. Limiting the depth keeps that work
+    /// proportional to the prompt size and also bounds the recursion in <see cref="GetPromptNode"/>.
+    /// </remarks>
+    internal const int MaxElementDepth = 64;
+
     /// <summary>
     /// Parses text prompt and sets output as collection of <see cref="PromptNode"/> instances.
     /// </summary>
     /// <param name="prompt">Text prompt to parse.</param>
     /// <param name="result">Parsing output as collection of <see cref="PromptNode"/> instances.</param>
-    /// <returns>Returns true if parsing was successful, otherwise false.</returns>
+    /// <returns>
+    /// Returns true if parsing was successful, otherwise false. Prompts whose elements are nested deeper than
+    /// <see cref="MaxElementDepth"/> are not parsed.
+    /// </returns>
     public static bool TryParse(string prompt, [NotNullWhen(true)] out List<PromptNode>? result)
     {
         result = null;
@@ -57,6 +71,13 @@ public static bool TryParse(string prompt, [NotNullWhen(true)] out List<PromptNo
             return false;
         }
 
+        // Check the depth before building prompt nodes, because building them serializes every subtree.
+        // A rejected prompt takes the same path as invalid XML, so callers use it as plain text.
+        if (ExceedsMaxElementDepth(xmlDocument.DocumentElement!))
+        {
+            return false;
+        }
+
         foreach (XmlNode node in xmlDocument.DocumentElement!.ChildNodes)
         {
             if (GetPromptNode(node) is { } childPromptNode)
@@ -115,4 +136,48 @@ public static bool TryParse(string prompt, [NotNullWhen(true)] out List<PromptNo
 
         return promptNode;
     }
+
+    /// <summary>
+    /// Checks whether any element below <paramref name="root"/> is nested deeper than <see cref="MaxElementDepth"/>.
+    /// </summary>
+    /// <param name="root">The wrapper element that contains the top-level prompt elements.</param>
+    private static bool ExceedsMaxElementDepth(XmlElement root)
+    {
+        // Walk the tree without recursion so that a deeply nested document cannot exhaust the stack here.
+        var depth = 1;
+        var node = root.FirstChild;
+
+        while (node is not null)
+        {
+            if (node.NodeType == XmlNodeType.Element)
+            {
+                if (depth > MaxElementDepth)
+                {
+                    return true;
+                }
+
+                if (node.FirstChild is { } firstChild)
+                {
+                    node = firstChild;
+                    depth++;
+                    continue;
+                }
+            }
+
+            // Move to the next sibling, climbing back up through parents that have no further siblings.
+            while (node.NextSibling is null)
+            {
+                node = node.ParentNode!;
+                if (--depth == 0)
+                {
+                    // Climbing to depth 0 means the walk has returned to the root element.
+                    return false;
+                }
+            }
+
+            node = node.NextSibling;
+        }
+
+        return false;
+    }
 }
@@ -24,6 +24,32 @@ public void ItReturnsNullChatHistoryWhenPromptIsPlainTextOrInvalid(string prompt
         Assert.Null(chatHistory);
     }
 
+    [Fact]
+    public void ItReturnsNullChatHistoryWhenMessageContentExceedsMaximumElementDepth()
+    {
+        // Arrange
+        var nestedContent = new StringBuilder();
+        for (var i = 1; i < XmlPromptParser.MaxElementDepth + 1; i++)
+        {
+            nestedContent.Append("<element>");
+        }
+
+        nestedContent.Append("content");
+        for (var i = 1; i < XmlPromptParser.MaxElementDepth + 1; i++)
+        {
+            nestedContent.Append("</element>");
+        }
+
+        var prompt = $"<message role='system'>System message.</message><message role='user'>{nestedContent}</message>";
+
+        // Act
+        var result = ChatPromptParser.TryParse(prompt, out var chatHistory);
+
+        // Assert
+        Assert.False(result);
+        Assert.Null(chatHistory);
+    }
+
     [Fact]
     public void ItReturnsChatHistoryWithValidRolesWhenPromptIsValid()
     {
 
@@ -2,6 +2,7 @@
 
 using System.Collections.Generic;
 using System.Linq;
+using System.Text;
 using Microsoft.SemanticKernel;
 using Xunit;
 
@@ -77,6 +78,85 @@ Test line with tab.
         }
     }
 
+    [Fact]
+    public void ItParsesPromptAtMaximumElementDepth()
+    {
+        // Arrange
+        var prompt = CreateNestedPrompt(XmlPromptParser.MaxElementDepth) + CreateNestedPrompt(XmlPromptParser.MaxElementDepth);
+
+        // Act
+        var result = XmlPromptParser.TryParse(prompt, out var nodes);
+
+        // Assert
+        Assert.True(result);
+        Assert.NotNull(nodes);
+        Assert.Equal(2, nodes.Count);
+
+        foreach (var node in nodes)
+        {
+            var current = node;
+            var depth = 1;
+            while (current.ChildNodes.Count > 0)
+            {
+                current = Assert.Single(current.ChildNodes);
+                depth++;
+            }
+
+            Assert.Equal(XmlPromptParser.MaxElementDepth, depth);
+            Assert.Equal("content", current.Content);
+        }
+    }
+
+    [Theory]
+    [InlineData(1)]
+    [InlineData(1000)]
+    public void ItReturnsFalseWhenPromptExceedsMaximumElementDepth(int extraDepth)
+    {
+        // Arrange
+        var prompt = CreateNestedPrompt(XmlPromptParser.MaxElementDepth + extraDepth);
+
+        // Act
+        var result = XmlPromptParser.TryParse(prompt, out var nodes);
+
+        // Assert
+        Assert.False(result);
+        Assert.Null(nodes);
+    }
+
+    [Fact]
+    public void ItReturnsFalseWhenLaterPromptNodeExceedsMaximumElementDepth()
+    {
+        // Arrange
+        var prompt = CreateNestedPrompt(XmlPromptParser.MaxElementDepth) + CreateNestedPrompt(XmlPromptParser.MaxElementDepth + 1);
+
+        // Act
+        var result = XmlPromptParser.TryParse(prompt, out var nodes);
+
+        // Assert
+        Assert.False(result);
+        Assert.Null(nodes);
+    }
+
+    /// <summary>
+    /// Creates a message element whose total element nesting depth, including the message itself, is <paramref name="depth"/>.
+    /// </summary>
+    private static string CreateNestedPrompt(int depth)
+    {
+        var builder = new StringBuilder("<message role=\"user\">");
+        for (var i = 1; i < depth; i++)
+        {
+            builder.Append("<element>");
+        }
+
+        builder.Append("content");
+        for (var i = 1; i < depth; i++)
+        {
+            builder.Append("</element>");
+        }
+
+        return builder.Append("</message>").ToString();
+    }
+
     private void AssertPromptNode(PromptNode expectedNode, PromptNode actualNode)
     {
         Assert.Equal(expectedNode.TagName, expectedNode.TagName);