Improved the Web Based Harness

DebugTools/MccMcpWebPlayground/Infrastructure/Mcp/MccMcpSessionFactory.cs

@@ -0,0 +1,200 @@
+using System.Text;
+using System.Text.Json;
+using System.Reflection;
+using DebugTools.MccMcpWebPlayground.Harness;
+using Microsoft.Extensions.Options;
+using ModelContextProtocol.Client;
+using ModelContextProtocol.Protocol;
+
+namespace DebugTools.MccMcpWebPlayground.Infrastructure.Mcp;
+
+public sealed class MccMcpSessionFactory
+{
+    private readonly MccWebHarnessOptions options;
+
+    public MccMcpSessionFactory(IOptions<MccWebHarnessOptions> options)
+    {
+        this.options = options.Value;
+    }
+
+    public async Task<McpClient> CreateAsync(CancellationToken cancellationToken)
+    {
+        string endpoint = options.ResolveMcpEndpoint();
+        string? token = options.ResolveMcpAuthToken();
+
+        return await McpClient.CreateAsync(new HttpClientTransport(new HttpClientTransportOptions
+        {
+            Endpoint = new Uri(endpoint),
+            TransportMode = HttpTransportMode.AutoDetect,
+            AdditionalHeaders = string.IsNullOrWhiteSpace(token)
+                ? null
+                : new Dictionary<string, string>
+                {
+                    ["Authorization"] = $"Bearer {token}"
+                }
+        }), cancellationToken: cancellationToken);
+    }
+}
+
+public static class MccMcpJson
+{
+    public static MccNormalizedToolResult Normalize(CallToolResult result)
+    {
+        JsonElement? structuredRoot = TryReadStructuredContent(result);
+        string text = ReadToolResultText(result, structuredRoot);
+        try
+        {
+            using JsonDocument document = JsonDocument.Parse(text);
+            JsonElement parsedRoot = document.RootElement.Clone();
+            JsonElement root = ShouldPreferStructuredRoot(parsedRoot, structuredRoot)
+                ? structuredRoot!.Value
+                : parsedRoot;
+            JsonElement? data = root.TryGetProperty("data", out JsonElement dataElement)
+                ? dataElement.Clone()
+                : ShouldTreatRootAsData(root) ? root.Clone() : structuredRoot;
+            bool success = root.TryGetProperty("success", out JsonElement successElement)
+                ? successElement.ValueKind != JsonValueKind.False
+                : result.IsError != true;
+            string? errorCode = root.TryGetProperty("errorCode", out JsonElement errorCodeElement) && errorCodeElement.ValueKind == JsonValueKind.String
+                ? errorCodeElement.GetString()
+                : null;
+            string? message = root.TryGetProperty("message", out JsonElement messageElement) && messageElement.ValueKind == JsonValueKind.String
+                ? messageElement.GetString()
+                : null;
+            bool isError = result.IsError == true || !success || !string.IsNullOrWhiteSpace(errorCode);
+
+            return new MccNormalizedToolResult(text, isError, success, errorCode, message, root, data);
+        }
+        catch
+        {
+            bool isError = result.IsError == true;
+            return new MccNormalizedToolResult(text, isError, !isError, null, null, structuredRoot, structuredRoot);
+        }
+    }
+
+    private static string ReadToolResultText(CallToolResult result, JsonElement? structuredRoot)
+    {
+        if (result.Content is null)
+            return structuredRoot?.GetRawText() ?? (result.IsError == true ? "{\"success\":false}" : "{\"success\":true}");
+
+        StringBuilder builder = new();
+        foreach (ContentBlock block in result.Content)
+        {
+            if (block is TextContentBlock text && !string.IsNullOrWhiteSpace(text.Text))
+            {
+                if (builder.Length > 0)
+                    builder.Append('\n');
+                builder.Append(text.Text);
+            }
+        }
+
+        return builder.Length > 0
+            ? builder.ToString()
+            : structuredRoot?.GetRawText()
+                ?? JsonSerializer.Serialize(new { success = result.IsError != true, isError = result.IsError });
+    }
+
+    private static JsonElement? TryReadStructuredContent(CallToolResult result)
+    {
+        PropertyInfo? property = typeof(CallToolResult).GetProperty("StructuredContent", BindingFlags.Instance | BindingFlags.Public);
+        if (property?.GetValue(result) is not { } value)
+            return null;
+
+        return value switch
+        {
+            JsonElement json when json.ValueKind != JsonValueKind.Undefined && json.ValueKind != JsonValueKind.Null => json.Clone(),
+            JsonDocument document => document.RootElement.Clone(),
+            string text when !string.IsNullOrWhiteSpace(text) => TryParseJson(text),
+            _ => TrySerializeToJson(value)
+        };
+    }
+
+    private static JsonElement? TrySerializeToJson(object value)
+    {
+        try
+        {
+            return JsonSerializer.SerializeToElement(value);
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    private static JsonElement? TryParseJson(string text)
+    {
+        try
+        {
+            using JsonDocument document = JsonDocument.Parse(text);
+            return document.RootElement.Clone();
+        }
+        catch
+        {
+            return null;
+        }
+    }
+
+    private static bool ShouldPreferStructuredRoot(JsonElement parsedRoot, JsonElement? structuredRoot)
+    {
+        if (structuredRoot is null)
+            return false;
+
+        if (parsedRoot.ValueKind != JsonValueKind.Object)
+            return true;
+
+        return !parsedRoot.EnumerateObject().Any(property =>
+            !property.NameEquals("success") &&
+            !property.NameEquals("isError"));
+    }
+
+    private static bool ShouldTreatRootAsData(JsonElement root)
+    {
+        if (root.ValueKind != JsonValueKind.Object)
+            return false;
+
+        return root.EnumerateObject().Any(property =>
+            !property.NameEquals("success") &&
+            !property.NameEquals("isError") &&
+            !property.NameEquals("errorCode") &&
+            !property.NameEquals("message"));
+    }
+}
+
+public static class MccJsonArguments
+{
+    public static Dictionary<string, object?> Parse(string rawJson)
+    {
+        try
+        {
+            using JsonDocument document = JsonDocument.Parse(string.IsNullOrWhiteSpace(rawJson) ? "{}" : rawJson);
+            if (document.RootElement.ValueKind != JsonValueKind.Object)
+                return new Dictionary<string, object?>();
+
+            Dictionary<string, object?> values = new(StringComparer.OrdinalIgnoreCase);
+            foreach (JsonProperty property in document.RootElement.EnumerateObject())
+                values[property.Name] = Convert(property.Value);
+            return values;
+        }
+        catch
+        {
+            return new Dictionary<string, object?>();
+        }
+    }
+
+    private static object? Convert(JsonElement element)
+    {
+        return element.ValueKind switch
+        {
+            JsonValueKind.Null => null,
+            JsonValueKind.True => true,
+            JsonValueKind.False => false,
+            JsonValueKind.Number => element.TryGetInt64(out long i64)
+                ? i64
+                : element.TryGetDouble(out double d) ? d : element.GetRawText(),
+            JsonValueKind.String => element.GetString(),
+            JsonValueKind.Array => element.EnumerateArray().Select(Convert).ToArray(),
+            JsonValueKind.Object => element.EnumerateObject().ToDictionary(property => property.Name, property => Convert(property.Value)),
+            _ => element.GetRawText()
+        };
+    }
+}