.Net: Fix #13232: Add empty parameters schema for NonInvocableTool placeholder (#13278)

### Motivation and Context

<!-- Thank you for your contribution to the semantic-kernel repo!
Please help reviewers and future users, providing the following
information:
  1. Why is this change required?
  2. What problem does it solve?
  3. What scenario does it contribute to?
  4. If it fixes an open issue, please link to the issue here.
-->

1. Why is this change required?
NonInvocableTool placeholder is created without a parameters field,
which causes 422 errors when used with Mistral models via LiteLLM since
Mistral enforces stricter JSON schema validation than other AI
providers.

2. What problem does it solve?
Current Issue:
When Semantic Kernel has no invocable tools but needs to send tools to
keep the service happy, it includes the NonInvocableTool placeholder.
This lacks a parameters field, causing Mistral APIs to reject requests.

3. What scenario does it contribute to?
This fix enables SK to work with:
- Mistral cloud APIs
- Any AI provider with strict schema validation requirements

Use Cases:
Applications using Mistral as their AI provider
Enterprise applications with strict API validation requirements

 4. Fixes: #13232 
 
### Description

<!-- Describe your changes, the overall approach, the underlying design.
These notes will help understanding how your code works. Thanks! -->

Solution
Updated the NonInvocableTool creation to include a proper empty
parameters schema that satisfies Mistral's validation requirements while
maintaining backward compatibility with all other providers

Changes Made
File: src/Connectors/Connectors.OpenAI/Core/ClientCore.ChatCompletion.cs
Line 61-64: Enhanced s_nonInvocableFunctionTool with proper parameters
schema
Added: Comprehensive unit tests verifying schema structure and Mistral
compatibility
Existing Tests: All 474 OpenAI connector tests pass (1 skipped)

Integration Tests: Verified with local Mistral via Ollama + LiteLLM
Backward Compatibility: Confirmed no breaking changes with OpenAI and
other providers

Note: I 've noticed that this similar empty schema is used as a property
called `s_zeroFunctionParametersSchema` that exists at
`OpenAIFunction.cs`

### 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 😄

Co-authored-by: Roger Barreto <19890735+rogerbarreto@users.noreply.github.com>

Author: icyca

dotnet/src/Connectors/Connectors.OpenAI.UnitTests/Core/ClientCoreTests.cs

@@ -399,4 +399,78 @@ private void AddMessagesWithFunctionCallsWithValidFunctionName()
             }), false);
         }
     }
+
+    [Fact]
+    public void NonInvocableToolHasValidParametersSchema()
+    {
+        // Arrange & Act
+        // Access the NonInvocableTool through reflection since it's protected
+        var clientCoreType = typeof(ClientCore);
+        var nonInvocableToolField = clientCoreType.GetField("s_nonInvocableFunctionTool",
+            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
+
+        Assert.NotNull(nonInvocableToolField);
+
+        var nonInvocableTool = (ChatTool)nonInvocableToolField.GetValue(null)!;
+
+        // Assert
+        Assert.NotNull(nonInvocableTool);
+        Assert.Equal("NonInvocableTool", nonInvocableTool.FunctionName);
+        Assert.Equal("A placeholder tool used when no real tools are available", nonInvocableTool.FunctionDescription);
+
+        // Verify that parameters are not null (this is the key fix for Mistral compatibility)
+        Assert.NotNull(nonInvocableTool.FunctionParameters);
+
+        // Verify the parameters contain a valid JSON schema
+        var parametersJson = nonInvocableTool.FunctionParameters.ToString();
+        Assert.Contains("\"type\":\"object\"", parametersJson);
+        Assert.Contains("\"required\":[]", parametersJson);
+        Assert.Contains("\"properties\":{}", parametersJson);
+
+        // Verify it's valid JSON
+        var parsedJson = JsonSerializer.Deserialize<JsonElement>(parametersJson);
+        Assert.Equal(JsonValueKind.Object, parsedJson.ValueKind);
+        Assert.True(parsedJson.TryGetProperty("type", out var typeProperty));
+        Assert.Equal("object", typeProperty.GetString());
+        Assert.True(parsedJson.TryGetProperty("required", out var requiredProperty));
+        Assert.Equal(JsonValueKind.Array, requiredProperty.ValueKind);
+        Assert.Equal(0, requiredProperty.GetArrayLength());
+        Assert.True(parsedJson.TryGetProperty("properties", out var propertiesProperty));
+        Assert.Equal(JsonValueKind.Object, propertiesProperty.ValueKind);
+    }
+
+    [Fact]
+    public void NonInvocableToolSchemaIsCompatibleWithMistral()
+    {
+        // Arrange & Act
+        var clientCoreType = typeof(ClientCore);
+        var nonInvocableToolField = clientCoreType.GetField("s_nonInvocableFunctionTool",
+            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
+
+        var nonInvocableTool = (ChatTool)nonInvocableToolField!.GetValue(null)!;
+
+        // Assert
+        // This test verifies that the tool schema meets Mistral's requirements:
+        // 1. Has a parameters field (not null)
+        // 2. Parameters field contains valid JSON schema
+        // 3. Schema has required type, properties, and required fields
+
+        Assert.NotNull(nonInvocableTool.FunctionParameters);
+
+        var parametersJson = nonInvocableTool.FunctionParameters.ToString();
+        var schema = JsonSerializer.Deserialize<JsonElement>(parametersJson);
+
+        // Verify all required fields for Mistral compatibility
+        Assert.True(schema.TryGetProperty("type", out _), "Schema must have 'type' field");
+        Assert.True(schema.TryGetProperty("properties", out _), "Schema must have 'properties' field");
+        Assert.True(schema.TryGetProperty("required", out _), "Schema must have 'required' field");
+
+        // Verify the schema structure matches what Mistral expects
+        Assert.Equal("object", schema.GetProperty("type").GetString());
+        Assert.Equal(JsonValueKind.Object, schema.GetProperty("properties").ValueKind);
+        Assert.Equal(JsonValueKind.Array, schema.GetProperty("required").ValueKind);
+
+        // This ensures the tool won't cause 422 errors with Mistral APIs
+        // as described in GitHub issue #13232
+    }
 }

dotnet/src/Connectors/Connectors.OpenAI/Core/ClientCore.ChatCompletion.cs

@@ -58,7 +58,10 @@ protected record ToolCallingConfig(IList<ChatTool>? Tools, ChatToolChoice? Choic
     protected const int MaxInflightAutoInvokes = 128;
 
     /// <summary>Singleton tool used when tool call count drops to 0 but we need to supply tools to keep the service happy.</summary>
-    protected static readonly ChatTool s_nonInvocableFunctionTool = ChatTool.CreateFunctionTool("NonInvocableTool");
+    protected static readonly ChatTool s_nonInvocableFunctionTool = ChatTool.CreateFunctionTool(
+        functionName: "NonInvocableTool",
+        functionDescription: "A placeholder tool used when no real tools are available",
+        functionParameters: BinaryData.FromString("""{"type":"object","required":[],"properties":{}}"""));
 
     /// <summary>
     /// Instance of <see cref="Meter"/> for metrics.