fix(llm): normalize native tool call metadata

Author: ModerRAS

TelegramSearchBot.LLM.Test/Service/AI/LLM/OpenAIToolCallNormalizationTests.cs

@@ -0,0 +1,44 @@
+using TelegramSearchBot.Service.AI.LLM;
+using Xunit;
+
+namespace TelegramSearchBot.LLM.Test.Service.AI.LLM {
+    public class OpenAIToolCallNormalizationTests {
+        [Fact]
+        public void NormalizeToolCallId_EmptyValue_GeneratesNonEmptyFallback() {
+            var id = OpenAIService.NormalizeToolCallId(string.Empty);
+
+            Assert.False(string.IsNullOrWhiteSpace(id));
+            Assert.StartsWith("call_", id);
+        }
+
+        [Fact]
+        public void NormalizeToolCallId_NonEmptyValue_TrimsAndPreservesValue() {
+            var id = OpenAIService.NormalizeToolCallId(" call_123 ");
+
+            Assert.Equal("call_123", id);
+        }
+
+        [Fact]
+        public void NormalizeToolCallArguments_EmptyValue_ReturnsEmptyJsonObject() {
+            var arguments = OpenAIService.NormalizeToolCallArguments("");
+
+            Assert.Equal("{}", arguments);
+        }
+
+        [Fact]
+        public void DeserializeToolArgumentsForDisplay_ConvertsNonStringValues() {
+            var arguments = OpenAIService.DeserializeToolArgumentsForDisplay("{\"count\":2,\"enabled\":true,\"text\":\"hello\"}");
+
+            Assert.Equal("2", arguments["count"]);
+            Assert.Equal("True", arguments["enabled"]);
+            Assert.Equal("hello", arguments["text"]);
+        }
+
+        [Fact]
+        public void DeserializeToolArgumentsForDisplay_InvalidJson_ReturnsEmptyDictionary() {
+            var arguments = OpenAIService.DeserializeToolArgumentsForDisplay("{not json");
+
+            Assert.Empty(arguments);
+        }
+    }
+}

TelegramSearchBot.LLM/Service/AI/LLM/OpenAIService.cs

@@ -44,6 +44,35 @@ private class ToolCallAccumulator {
             public StringBuilder Arguments { get; } = new StringBuilder();
         }
 
+        internal static string NormalizeToolCallId(string toolCallId) {
+            return string.IsNullOrWhiteSpace(toolCallId)
+                ? $"call_{Guid.NewGuid():N}"
+                : toolCallId.Trim();
+        }
+
+        internal static string NormalizeToolCallName(string toolCallName) {
+            return string.IsNullOrWhiteSpace(toolCallName)
+                ? "unknown"
+                : toolCallName.Trim();
+        }
+
+        internal static string NormalizeToolCallArguments(string argumentsJson) {
+            return string.IsNullOrWhiteSpace(argumentsJson) ? "{}" : argumentsJson;
+        }
+
+        internal static Dictionary<string, string> DeserializeToolArgumentsForDisplay(string argumentsJson) {
+            try {
+                var normalized = NormalizeToolCallArguments(argumentsJson);
+                var values = JsonConvert.DeserializeObject<Dictionary<string, object>>(normalized);
+                return values?.ToDictionary(
+                    kvp => kvp.Key,
+                    kvp => kvp.Value?.ToString() ?? string.Empty)
+                    ?? new Dictionary<string, string>();
+            } catch {
+                return new Dictionary<string, string>();
+            }
+        }
+
         private readonly ILogger<OpenAIService> _logger;
         public static string _botName;
         public string BotName {
@@ -1022,13 +1051,16 @@ private async IAsyncEnumerable<string> ExecWithNativeToolCallingAsync(
                             // Build the assistant message with tool calls
                             chatToolCalls = new List<ChatToolCall>();
                             foreach (var (index, acc) in toolCallAccumulators) {
-                                if (acc.Id == null) {
+                                if (string.IsNullOrWhiteSpace(acc.Id)) {
                                     _logger.LogWarning("{ServiceName}: Tool call at index {Index} has no ID, generating fallback.", ServiceName, index);
                                 }
+                                var toolCallId = NormalizeToolCallId(acc.Id);
+                                var toolName = NormalizeToolCallName(acc.Name);
+                                var argumentsJson = NormalizeToolCallArguments(acc.Arguments.ToString());
                                 chatToolCalls.Add(ChatToolCall.CreateFunctionToolCall(
-                                    acc.Id ?? $"call_{Guid.NewGuid():N}",
-                                    acc.Name ?? "unknown",
-                                    BinaryData.FromString(acc.Arguments.Length > 0 ? acc.Arguments.ToString() : "{}")));
+                                    toolCallId,
+                                    toolName,
+                                    BinaryData.FromString(argumentsJson)));
                             }
 
                             var assistantMessage = new AssistantChatMessage(chatToolCalls);
@@ -1041,15 +1073,13 @@ private async IAsyncEnumerable<string> ExecWithNativeToolCallingAsync(
 
                             var toolIndicators = new StringBuilder();
                             foreach (var toolCall in chatToolCalls) {
-                                var argsJson = toolCall.FunctionArguments?.ToString() ?? "{}";
-                                var argsDict = JsonConvert.DeserializeObject<Dictionary<string, string>>(argsJson)
-                                    ?? new Dictionary<string, string>();
+                                var argsDict = DeserializeToolArgumentsForDisplay(toolCall.FunctionArguments?.ToString());
                                 toolIndicators.Append(McpToolHelper.FormatToolCallDisplay(toolCall.FunctionName, argsDict));
                             }
                             currentMessageContentBuilder.Append(toolIndicators.ToString());
                         } catch (Exception ex) {
                             _logger.LogError(ex, "{ServiceName}: Error building tool calls, returning error to LLM for self-correction", ServiceName);
-                            var errorMsg = $"Error processing tool call: {ex.Message}. Please check your tool call parameters and try again.";
+                            const string errorMsg = "Tool call failed before execution due to malformed tool metadata. Please verify the tool name and parameters, then try again.";
                             providerHistory.Add(new UserChatMessage(errorMsg));
                             continue;
                         }
@@ -1065,7 +1095,7 @@ private async IAsyncEnumerable<string> ExecWithNativeToolCallingAsync(
                                 string toolResultString;
                                 try {
                                     // Parse arguments from JSON
-                                    var argsJson = toolCall.FunctionArguments?.ToString() ?? "{}";
+                                    var argsJson = NormalizeToolCallArguments(toolCall.FunctionArguments?.ToString());
                                     var argsDict = JsonConvert.DeserializeObject<Dictionary<string, string>>(argsJson)
                                         ?? new Dictionary<string, string>();
 

TelegramSearchBot.LLM/TelegramSearchBot.LLM.csproj

@@ -6,6 +6,10 @@
     <Nullable>warnings</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <InternalsVisibleTo Include="TelegramSearchBot.LLM.Test" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Anthropic" Version="12.16.0" />
     <PackageReference Include="Google_GenerativeAI" Version="3.6.6" />