Merge branch 'main' into codex/semantic-kernel-azure-response-format

Author: MukundaKatta

dotnet/SK-release.slnf

@@ -32,22 +32,6 @@
       "src\\Connectors\\Connectors.Onnx\\Connectors.Onnx.csproj",
       "src\\Connectors\\Connectors.OpenAI\\Connectors.OpenAI.csproj",
 
-      "src\\VectorData\\AzureAISearch\\AzureAISearch.csproj",
-      "src\\VectorData\\Chroma\\Chroma.csproj",
-      "src\\VectorData\\CosmosMongoDB\\CosmosMongoDB.csproj",
-      "src\\VectorData\\CosmosNoSql\\CosmosNoSql.csproj",
-      "src\\VectorData\\InMemory\\InMemory.csproj",
-      "src\\VectorData\\Milvus\\Milvus.csproj",
-      "src\\VectorData\\MongoDB\\MongoDB.csproj",
-      "src\\VectorData\\PgVector\\PgVector.csproj",
-      "src\\VectorData\\Pinecone\\Pinecone.csproj",
-      "src\\VectorData\\Qdrant\\Qdrant.csproj",
-      "src\\VectorData\\Redis\\Redis.csproj",
-      "src\\VectorData\\SqliteVec\\SqliteVec.csproj",
-      "src\\VectorData\\SqlServer\\SqlServer.csproj",
-      "src\\VectorData\\VectorData.Abstractions\\VectorData.Abstractions.csproj",
-      "src\\VectorData\\Weaviate\\Weaviate.csproj",
-
       "src\\Experimental\\Orchestration.Flow\\Experimental.Orchestration.Flow.csproj",
 
       "src\\Experimental\\Process.Abstractions\\Process.Abstractions.csproj",

dotnet/src/Experimental/Process.Core/ProcessStepBuilder.cs

@@ -278,6 +278,10 @@ internal ProcessStepBuilderTyped(Type stepType, string id, ProcessBuilder? proce
         : base(id, processBuilder)
     {
         Verify.NotNull(stepType);
+        if (!typeof(KernelProcessStep).IsAssignableFrom(stepType))
+        {
+            throw new ArgumentException($"Type '{stepType.FullName}' must be a subclass of KernelProcessStep.", nameof(stepType));
+        }
 
         this._stepType = stepType;
         this.FunctionsDict = this.GetFunctionMetadataMap();

dotnet/src/Experimental/Process.Runtime.Dapr.UnitTests/DaprStepInfoTests.cs

@@ -0,0 +1,86 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Collections.Generic;
+using Microsoft.SemanticKernel;
+using Xunit;
+
+namespace SemanticKernel.Process.Dapr.Runtime.UnitTests;
+
+/// <summary>
+/// Unit tests for the <see cref="DaprStepInfo"/> class.
+/// </summary>
+public class DaprStepInfoTests
+{
+    /// <summary>
+    /// Tests that ToKernelProcessStepInfo throws when InnerStepDotnetType is not a KernelProcessStep subclass.
+    /// </summary>
+    [Fact]
+    public void ToKernelProcessStepInfoThrowsForInvalidStepType()
+    {
+        // Arrange
+        var stepInfo = new DaprStepInfo
+        {
+            InnerStepDotnetType = typeof(string).AssemblyQualifiedName!,
+            State = new KernelProcessStepState("TestStep", version: "v1"),
+            Edges = new Dictionary<string, List<KernelProcessEdge>>()
+        };
+
+        // Act & Assert
+        var ex = Assert.Throws<KernelException>(() => stepInfo.ToKernelProcessStepInfo());
+        Assert.Contains("is not a valid KernelProcessStep type", ex.Message);
+    }
+
+    /// <summary>
+    /// Tests that ToKernelProcessStepInfo throws when InnerStepDotnetType cannot be resolved.
+    /// </summary>
+    [Fact]
+    public void ToKernelProcessStepInfoThrowsForUnresolvableType()
+    {
+        // Arrange
+        var stepInfo = new DaprStepInfo
+        {
+            InnerStepDotnetType = "NonExistent.Type, NonExistent.Assembly",
+            State = new KernelProcessStepState("TestStep", version: "v1"),
+            Edges = new Dictionary<string, List<KernelProcessEdge>>()
+        };
+
+        // Act & Assert
+        Assert.Throws<KernelException>(() => stepInfo.ToKernelProcessStepInfo());
+    }
+
+    /// <summary>
+    /// Tests that ToKernelProcessStepInfo succeeds for a valid KernelProcessStep subclass.
+    /// </summary>
+    [Fact]
+    public void ToKernelProcessStepInfoSucceedsForValidStepType()
+    {
+        // Arrange
+        var stepInfo = new DaprStepInfo
+        {
+            InnerStepDotnetType = typeof(ValidTestStep).AssemblyQualifiedName!,
+            State = new KernelProcessStepState("TestStep", version: "v1"),
+            Edges = new Dictionary<string, List<KernelProcessEdge>>()
+        };
+
+        // Act
+        var result = stepInfo.ToKernelProcessStepInfo();
+
+        // Assert
+        Assert.NotNull(result);
+        Assert.Equal(typeof(ValidTestStep), result.InnerStepType);
+    }
+
+    /// <summary>
+    /// A valid test step for type validation testing.
+    /// </summary>
+    public sealed class ValidTestStep : KernelProcessStep
+    {
+        /// <summary>
+        /// A test function.
+        /// </summary>
+        [KernelFunction]
+        public void TestFunction()
+        {
+        }
+    }
+}

dotnet/src/Experimental/Process.Runtime.Dapr.UnitTests/TypeInfoTests.cs

@@ -0,0 +1,74 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Text.Json;
+using Microsoft.SemanticKernel;
+using Microsoft.SemanticKernel.Process.Serialization;
+using Xunit;
+
+namespace SemanticKernel.Process.Dapr.Runtime.UnitTests;
+
+/// <summary>
+/// Unit tests for the <see cref="TypeInfo"/> class.
+/// </summary>
+public class TypeInfoTests
+{
+    /// <summary>
+    /// Tests that ConvertValue deserializes a JsonElement to the correct type.
+    /// </summary>
+    [Fact]
+    public void ConvertValueDeserializesJsonElement()
+    {
+        // Arrange
+        var json = JsonSerializer.SerializeToElement(42);
+        var typeName = typeof(int).AssemblyQualifiedName;
+
+        // Act
+        var result = TypeInfo.ConvertValue(typeName, json);
+
+        // Assert
+        Assert.Equal(42, result);
+    }
+
+    /// <summary>
+    /// Tests that ConvertValue throws when the type name cannot be resolved.
+    /// </summary>
+    [Fact]
+    public void ConvertValueThrowsForUnresolvableType()
+    {
+        // Arrange
+        var json = JsonSerializer.SerializeToElement(42);
+
+        // Act & Assert
+        Assert.Throws<KernelException>(() =>
+            TypeInfo.ConvertValue("NonExistent.Type, NonExistent.Assembly", json));
+    }
+
+    /// <summary>
+    /// Tests that ConvertValue returns non-JsonElement values unchanged.
+    /// </summary>
+    [Fact]
+    public void ConvertValueReturnsNonJsonElementUnchanged()
+    {
+        // Arrange
+        var value = "plain string";
+
+        // Act
+        var result = TypeInfo.ConvertValue(typeof(string).AssemblyQualifiedName, value);
+
+        // Assert
+        Assert.Equal("plain string", result);
+    }
+
+    /// <summary>
+    /// Tests that ConvertValue returns null when value is null.
+    /// </summary>
+    [Fact]
+    public void ConvertValueReturnsNullWhenValueIsNull()
+    {
+        // Act
+        var result = TypeInfo.ConvertValue(typeof(string).AssemblyQualifiedName, null);
+
+        // Assert
+        Assert.Null(result);
+    }
+}

dotnet/src/Experimental/Process.Runtime.Dapr/Actors/StepActor.cs

@@ -102,6 +102,11 @@ private void InitializeStep(DaprStepInfo stepInfo, string? parentProcessId, stri
             throw new KernelException($"Could not load the inner step type '{stepInfo.InnerStepDotnetType}'.").Log(this._logger);
         }
 
+        if (!typeof(KernelProcessStep).IsAssignableFrom(this._innerStepType))
+        {
+            throw new KernelException($"Type '{stepInfo.InnerStepDotnetType}' is not a valid KernelProcessStep type.").Log(this._logger);
+        }
+
         this.ParentProcessId = parentProcessId;
         this._stepInfo = stepInfo;
         this._stepState = this._stepInfo.State;
@@ -373,8 +378,18 @@ protected virtual async ValueTask ActivateStepAsync()
         if (stepStateType.HasValue)
         {
             stateType = Type.GetType(stepStateType.Value);
+            if (stateType is null)
+            {
+                throw new KernelException($"Type '{stepStateType.Value}' could not be resolved to a valid KernelProcessStepState type.").Log(this._logger);
+            }
+
+            if (!typeof(KernelProcessStepState).IsAssignableFrom(stateType))
+            {
+                throw new KernelException($"Type '{stepStateType.Value}' is not a valid KernelProcessStepState type.").Log(this._logger);
+            }
+
             var stateObjectJson = await this.StateManager.GetStateAsync<string>(ActorStateKeys.StepStateJson).ConfigureAwait(false);
-            stateObject = JsonSerializer.Deserialize(stateObjectJson, stateType!) as KernelProcessStepState;
+            stateObject = JsonSerializer.Deserialize(stateObjectJson, stateType) as KernelProcessStepState;
         }
         else
         {

dotnet/src/Experimental/Process.Runtime.Dapr/DaprStepInfo.cs

@@ -50,6 +50,11 @@ public KernelProcessStepInfo ToKernelProcessStepInfo()
             throw new KernelException($"Unable to create inner step type from assembly qualified name `{this.InnerStepDotnetType}`");
         }
 
+        if (!typeof(KernelProcessStep).IsAssignableFrom(innerStepType))
+        {
+            throw new KernelException($"Type '{this.InnerStepDotnetType}' is not a valid KernelProcessStep type.");
+        }
+
         return new KernelProcessStepInfo(innerStepType, this.State, this.Edges);
     }
 

dotnet/src/Experimental/Process.Runtime.Dapr/Serialization/TypeInfo.cs

@@ -39,6 +39,11 @@ internal static class TypeInfo
         }
 
         Type? valueType = Type.GetType(assemblyQualifiedTypeName);
-        return ((JsonElement)value).Deserialize(valueType!);
+        if (valueType is null)
+        {
+            throw new KernelException($"Could not load type '{assemblyQualifiedTypeName}'.");
+        }
+
+        return ((JsonElement)value).Deserialize(valueType);
     }
 }

dotnet/src/Experimental/Process.UnitTests/Core/ProcessBuilderTests.cs

@@ -167,6 +167,37 @@ public void OnFunctionErrorCreatesEdgeBuilder()
         Assert.EndsWith("Global.OnError", edgeBuilder.EventData.EventId);
     }
 
+    /// <summary>
+    /// Tests that AddStepFromType(Type) throws ArgumentException for non-KernelProcessStep types.
+    /// </summary>
+    [Fact]
+    public void AddStepFromTypeWithInvalidTypeThrowsArgumentException()
+    {
+        // Arrange
+        var processBuilder = new ProcessBuilder(ProcessName);
+
+        // Act & Assert
+        var ex = Assert.Throws<ArgumentException>(() => processBuilder.AddStepFromType(typeof(string)));
+        Assert.Contains("must be a subclass of KernelProcessStep", ex.Message);
+    }
+
+    /// <summary>
+    /// Tests that AddStepFromType(Type) succeeds for valid KernelProcessStep types.
+    /// </summary>
+    [Fact]
+    public void AddStepFromTypeWithValidTypeAddsStep()
+    {
+        // Arrange
+        var processBuilder = new ProcessBuilder(ProcessName);
+
+        // Act
+        var stepBuilder = processBuilder.AddStepFromType(typeof(TestStep), StepName);
+
+        // Assert
+        Assert.Single(processBuilder.Steps);
+        Assert.Equal(StepName, stepBuilder.Name);
+    }
+
     /// <summary>
     /// A class that represents a step for testing.
     /// </summary>

dotnet/src/VectorData/Redis/RedisFilterTranslator.cs

@@ -258,8 +258,8 @@ private void TranslateAny(Expression source, LambdaExpression lambda)
 
     private static string SanitizeStringConstant(string value)
 #if NET
-        => value.Replace("\"", "\\\"", StringComparison.Ordinal);
+        => value.Replace("\\", "\\\\", StringComparison.Ordinal).Replace("\"", "\\\"", StringComparison.Ordinal);
 #else
-        => value.Replace("\"", "\\\"");
+        => value.Replace("\\", "\\\\").Replace("\"", "\\\"");
 #endif
 }

dotnet/src/VectorData/SqlServer/SqlServerCommandBuilder.cs

@@ -31,7 +31,7 @@ internal static List<SqlCommand> CreateTable(
         if (ifNotExists)
         {
             sb.Append("IF OBJECT_ID(N'");
-            sb.AppendTableName(schema, tableName);
+            sb.AppendTableNameInsideLiteral(schema, tableName);
             sb.AppendLine("', N'U') IS NULL");
         }
         sb.AppendLine("BEGIN");
@@ -125,22 +125,22 @@ internal static List<SqlCommand> CreateTable(
             // Full-text indexes require a unique index (we use the primary key)
             sb.AppendLine("DECLARE @pkIndexName NVARCHAR(128);");
             sb.Append("SELECT @pkIndexName = name FROM sys.indexes WHERE object_id = OBJECT_ID(N'");
-            sb.AppendTableName(schema, tableName);
+            sb.AppendTableNameInsideLiteral(schema, tableName);
             sb.AppendLine("') AND is_primary_key = 1;");
 
             sb.AppendLine("DECLARE @ftSql NVARCHAR(MAX);");
             sb.Append("SET @ftSql = N'CREATE FULLTEXT INDEX ON ");
-            sb.AppendTableName(schema, tableName).Append(" (");
+            sb.AppendTableNameInsideLiteral(schema, tableName).Append(" (");
             for (int i = 0; i < fullTextProperties.Count; i++)
             {
-                sb.AppendIdentifier(fullTextProperties[i].StorageName);
+                sb.AppendIdentifierInsideLiteral(fullTextProperties[i].StorageName);
                 if (i < fullTextProperties.Count - 1)
                 {
                     sb.Append(',');
                 }
             }
             sb.Append(") KEY INDEX ' + QUOTENAME(@pkIndexName) + N' ON ");
-            sb.AppendIdentifier(catalogName).AppendLine("';");
+            sb.AppendIdentifierInsideLiteral(catalogName).AppendLine("';");
             sb.AppendLine("EXEC sp_executesql @ftSql;");
         }
 
@@ -897,6 +897,30 @@ internal static StringBuilder AppendIdentifier(this StringBuilder sb, string ide
         return sb;
     }
 
+    /// <summary>
+    /// Same as <see cref="AppendTableName"/>, but for use inside a SQL string literal (N'...'),
+    /// where single quotes must be escaped by doubling them.
+    /// </summary>
+    internal static StringBuilder AppendTableNameInsideLiteral(this StringBuilder sb, string? schema, string tableName)
+    {
+        int start = sb.Length;
+        sb.AppendTableName(schema, tableName);
+        sb.Replace("'", "''", start, sb.Length - start);
+        return sb;
+    }
+
+    /// <summary>
+    /// Same as <see cref="AppendIdentifier"/>, but for use inside a SQL string literal (N'...'),
+    /// where single quotes must be escaped by doubling them.
+    /// </summary>
+    internal static StringBuilder AppendIdentifierInsideLiteral(this StringBuilder sb, string identifier)
+    {
+        int start = sb.Length;
+        sb.AppendIdentifier(identifier);
+        sb.Replace("'", "''", start, sb.Length - start);
+        return sb;
+    }
+
     private static StringBuilder AppendIdentifiers(this StringBuilder sb,
         IEnumerable<PropertyModel> properties,
         string? prefix = null,