.Net: [Error handling] [Part5] Replacing TemplateException exception by SKException (#2468)

### Motivation and Context

This PR is one of the follow-up PRs aimed at gradually replacing SK
custom exceptions with SKException to provide a simple, consistent, and
extensible exception model. You can find more details in the
[ADR](https://github.com/microsoft/semantic-kernel/blob/main/docs/decisions/0004-error-handling.md)
discussing error handling.

### Description

This PR updates the template engine functionality to throw an
SKException instead of a TemplateException and removes the
TemplateException one.

### Contribution Checklist

<!-- Before submitting this PR, please make sure: -->

- [x] The code builds clean without any errors or warnings
- [x] The PR follows the [SK Contribution
Guidelines](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md)
and the [pre-submission formatting
script](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md#development-scripts)
raises no violations
- [x] All unit tests pass, and I have added new tests where possible
- [x] I didn't break anyone 😄

Author: SergeyMenshykh

dotnet/src/IntegrationTests/TemplateLanguage/PromptTemplateEngineTests.cs

@@ -6,6 +6,7 @@
 using System.IO;
 using System.Threading.Tasks;
 using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.Diagnostics;
 using Microsoft.SemanticKernel.SkillDefinition;
 using Microsoft.SemanticKernel.TemplateEngine;
 using Xunit;
@@ -144,7 +145,7 @@ public async Task ItHandleEdgeCasesAsync(string template, string expectedResult)
         this._logger.WriteLine("expected: " + expectedResult);
         if (expectedResult.StartsWith("ERROR", StringComparison.OrdinalIgnoreCase))
         {
-            await Assert.ThrowsAsync<TemplateException>(
+            await Assert.ThrowsAsync<SKException>(
                 async () => await this._target.RenderAsync(template, kernel.CreateNewContext()));
         }
         else

dotnet/src/SemanticKernel.UnitTests/TemplateEngine/Blocks/CodeBlockTests.cs

@@ -7,9 +7,9 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
 using Microsoft.SemanticKernel.AI.TextCompletion;
+using Microsoft.SemanticKernel.Diagnostics;
 using Microsoft.SemanticKernel.Orchestration;
 using Microsoft.SemanticKernel.SkillDefinition;
-using Microsoft.SemanticKernel.TemplateEngine;
 using Microsoft.SemanticKernel.TemplateEngine.Blocks;
 using Moq;
 using Xunit;
@@ -35,11 +35,8 @@ public async Task ItThrowsIfAFunctionDoesntExistAsync()
         this._skills.Setup(x => x.TryGetFunction("functionName", out It.Ref<ISKFunction?>.IsAny)).Returns(false);
         var target = new CodeBlock("functionName", this._logger.Object);
 
-        // Act
-        var exception = await Assert.ThrowsAsync<TemplateException>(async () => await target.RenderCodeAsync(context));
-
-        // Assert
-        Assert.Equal(TemplateException.ErrorCodes.FunctionNotFound, exception.ErrorCode);
+        // Act & Assert
+        await Assert.ThrowsAsync<SKException>(async () => await target.RenderCodeAsync(context));
     }
 
     [Fact]
@@ -56,11 +53,8 @@ public async Task ItThrowsIfAFunctionCallThrowsAsync()
         this._skills.Setup(x => x.GetFunction("functionName")).Returns(function.Object);
         var target = new CodeBlock("functionName", this._logger.Object);
 
-        // Act
-        var exception = await Assert.ThrowsAsync<TemplateException>(async () => await target.RenderCodeAsync(context));
-
-        // Assert
-        Assert.Equal(TemplateException.ErrorCodes.RuntimeError, exception.ErrorCode);
+        // Act & Assert
+        await Assert.ThrowsAsync<SKException>(async () => await target.RenderCodeAsync(context));
     }
 
     [Fact]

dotnet/src/SemanticKernel.UnitTests/TemplateEngine/Blocks/FunctionIdBlockTests.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
 using Microsoft.Extensions.Logging.Abstractions;
-using Microsoft.SemanticKernel.TemplateEngine;
+using Microsoft.SemanticKernel.Diagnostics;
 using Microsoft.SemanticKernel.TemplateEngine.Blocks;
 using Xunit;
 
@@ -86,7 +86,7 @@ public void ItAllowsOnlyOneDot()
         // Arrange
         var target1 = new FunctionIdBlock("functionName");
         var target2 = new FunctionIdBlock("skillName.functionName");
-        Assert.Throws<TemplateException>(() => new FunctionIdBlock("foo.skillName.functionName"));
+        Assert.Throws<SKException>(() => new FunctionIdBlock("foo.skillName.functionName"));
 
         // Act + Assert
         Assert.True(target1.IsValid(out _));

dotnet/src/SemanticKernel.UnitTests/TemplateEngine/Blocks/VarBlockTests.cs

@@ -1,7 +1,7 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using Microsoft.SemanticKernel.Diagnostics;
 using Microsoft.SemanticKernel.Orchestration;
-using Microsoft.SemanticKernel.TemplateEngine;
 using Microsoft.SemanticKernel.TemplateEngine.Blocks;
 using Xunit;
 
@@ -96,8 +96,7 @@ public void ItThrowsIfTheVarNameIsEmpty()
         var target = new VarBlock(" $ ");
 
         // Act + Assert
-        var ex = Assert.Throws<TemplateException>(() => target.Render(variables));
-        Assert.Equal(TemplateException.ErrorCodes.SyntaxError, ex.ErrorCode);
+        Assert.Throws<SKException>(() => target.Render(variables));
     }
 
     [Theory]

dotnet/src/SemanticKernel.UnitTests/TemplateEngine/CodeTokenizerTests.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft. All rights reserved.
 
+using Microsoft.SemanticKernel.Diagnostics;
 using Microsoft.SemanticKernel.TemplateEngine;
 using Microsoft.SemanticKernel.TemplateEngine.Blocks;
 using Xunit;
@@ -129,15 +130,12 @@ public void ItSupportsEscaping()
         Assert.Equal("'f\'oo'", blocks[1].Content);
     }
 
-    [Fact]
-    public void ItThrowsWhenSeparatorsAreMissing()
+    [Theory]
+    [InlineData(@"call 'f\\'xy'")]
+    [InlineData(@"call 'f\\'x")]
+    public void ItThrowsWhenSeparatorsAreMissing(string template)
     {
-        // Arrange
-        var template1 = @"call 'f\\'xy'";
-        var template2 = @"call 'f\\'x";
-
-        // Act
-        Assert.Throws<TemplateException>(() => this._target.Tokenize(template1));
-        Assert.Throws<TemplateException>(() => this._target.Tokenize(template2));
+        // Act & Assert
+        Assert.Throws<SKException>(() => this._target.Tokenize(template));
     }
 }

dotnet/src/SemanticKernel.UnitTests/TemplateEngine/TemplateExceptionTests.cs

@@ -88,7 +88,7 @@ public async Task<string> RenderCodeAsync(SKContext context, CancellationToken c
     {
         if (!this._validated && !this.IsValid(out var error))
         {
-            throw new TemplateException(TemplateException.ErrorCodes.SyntaxError, error);
+            throw new SKException(error);
         }
 
         this.Logger.LogTrace("Rendering code: `{0}`", this.Content);
@@ -103,8 +103,7 @@ public async Task<string> RenderCodeAsync(SKContext context, CancellationToken c
                 return await this.RenderFunctionCallAsync((FunctionIdBlock)this._tokens[0], context).ConfigureAwait(false);
         }
 
-        throw new TemplateException(TemplateException.ErrorCodes.UnexpectedBlockType,
-            $"Unexpected first token type: {this._tokens[0].Type:G}");
+        throw new SKException($"Unexpected first token type: {this._tokens[0].Type:G}");
     }
 
     #region private ================================================================================
@@ -123,7 +122,7 @@ private async Task<string> RenderFunctionCallAsync(FunctionIdBlock fBlock, SKCon
         {
             var errorMsg = $"Function `{fBlock.Content}` not found";
             this.Logger.LogError(errorMsg);
-            throw new TemplateException(TemplateException.ErrorCodes.FunctionNotFound, errorMsg);
+            throw new SKException(errorMsg);
         }
 
         SKContext contextClone = context.Clone();
@@ -155,7 +154,7 @@ private async Task<string> RenderFunctionCallAsync(FunctionIdBlock fBlock, SKCon
         {
             var errorMsg = $"Function `{fBlock.Content}` execution failed. {contextClone.LastException?.GetType().FullName}: {contextClone.LastException?.Message}";
             this.Logger.LogError(errorMsg);
-            throw new TemplateException(TemplateException.ErrorCodes.RuntimeError, errorMsg, contextClone.LastException);
+            throw new SKException(errorMsg, contextClone.LastException);
         }
 
         return contextClone.Result;

dotnet/src/SemanticKernel/TemplateEngine/Blocks/CodeBlock.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Text.RegularExpressions;
 using Microsoft.Extensions.Logging;
+using Microsoft.SemanticKernel.Diagnostics;
 using Microsoft.SemanticKernel.Orchestration;
 
 namespace Microsoft.SemanticKernel.TemplateEngine.Blocks;
@@ -21,9 +22,8 @@ public FunctionIdBlock(string? text, ILogger? logger = null)
         var functionNameParts = this.Content.Split('.');
         if (functionNameParts.Length > 2)
         {
-            this.Logger.LogError("Invalid function name `{0}`", this.Content);
-            throw new TemplateException(TemplateException.ErrorCodes.SyntaxError,
-                "A function name can contain at most one dot separating the skill name from the function name");
+            this.Logger.LogError("Invalid function name `{FunctionName}`.", this.Content);
+            throw new SKException($"Invalid function name `{this.Content}`. A function name can contain at most one dot separating the skill name from the function name");
         }
 
         if (functionNameParts.Length == 2)

dotnet/src/SemanticKernel/TemplateEngine/Blocks/FunctionIdBlock.cs

@@ -2,6 +2,7 @@
 
 using System.Text.RegularExpressions;
 using Microsoft.Extensions.Logging;
+using Microsoft.SemanticKernel.Diagnostics;
 using Microsoft.SemanticKernel.Orchestration;
 
 namespace Microsoft.SemanticKernel.TemplateEngine.Blocks;
@@ -70,7 +71,7 @@ public string Render(ContextVariables? variables)
         {
             const string ErrMsg = "Variable rendering failed, the variable name is empty";
             this.Logger.LogError(ErrMsg);
-            throw new TemplateException(TemplateException.ErrorCodes.SyntaxError, ErrMsg);
+            throw new SKException(ErrMsg);
         }
 
         if (variables.TryGetValue(this.Name, out string? value))

dotnet/src/SemanticKernel/TemplateEngine/Blocks/VarBlock.cs

@@ -4,6 +4,7 @@
 using System.Text;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.SemanticKernel.Diagnostics;
 using Microsoft.SemanticKernel.TemplateEngine.Blocks;
 using Microsoft.SemanticKernel.Text;
 
@@ -188,8 +189,7 @@ public List<Block> Tokenize(string? text)
             {
                 if (!spaceSeparatorFound)
                 {
-                    throw new TemplateException(TemplateException.ErrorCodes.SyntaxError,
-                        "Tokens must be separated by one space least");
+                    throw new SKException("Tokens must be separated by one space least");
                 }
 
                 if (IsQuote(currentChar))
@@ -228,8 +228,7 @@ public List<Block> Tokenize(string? text)
                 break;
 
             case TokenTypes.None:
-                throw new TemplateException(TemplateException.ErrorCodes.SyntaxError,
-                    "Tokens must be separated by one space least");
+                throw new SKException("Tokens must be separated by one space least");
         }
 
         return blocks;

dotnet/src/SemanticKernel/TemplateEngine/CodeTokenizer.cs

@@ -7,6 +7,7 @@
 using System.Threading.Tasks;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.SemanticKernel.Diagnostics;
 using Microsoft.SemanticKernel.Orchestration;
 using Microsoft.SemanticKernel.TemplateEngine.Blocks;
 
@@ -46,7 +47,7 @@ public IList<Block> ExtractBlocks(string? templateText, bool validate = true)
             {
                 if (!block.IsValid(out var error))
                 {
-                    throw new TemplateException(TemplateException.ErrorCodes.SyntaxError, error);
+                    throw new SKException(error);
                 }
             }
         }
@@ -88,7 +89,7 @@ internal async Task<string> RenderAsync(IList<Block> blocks, SKContext context,
                 default:
                     const string Error = "Unexpected block type, the block doesn't have a rendering method";
                     this._logger.LogError(Error);
-                    throw new TemplateException(TemplateException.ErrorCodes.UnexpectedBlockType, Error);
+                    throw new SKException(Error);
             }
         }