Fix base64 deserialization with JSON-escaped data in ImageContentBlock, AudioContentBlock, and BlobResourceContents

The ContentBlock.Converter and ResourceContents.Converter were using
reader.ValueSpan.ToArray() to read base64-encoded data from JSON strings.
This reads raw bytes without unescaping JSON escape sequences. When base64
data contains '/' characters that are JSON-escaped as '\/' (a valid JSON
escape used by some encoders), the backslash corrupts the base64 data,
causing "Invalid base64 data" FormatException on access to DecodedData.

Fix: Check reader.ValueIsEscaped and fall back to GetString() + UTF8
encoding when escape sequences are present, preserving the fast path
for the common unescaped case.

Fixes #1340

Co-authored-by: stephentoub <2642209+stephentoub@users.noreply.github.com>

Author: Copilot

src/ModelContextProtocol.Core/Protocol/ContentBlock.cs

@@ -4,6 +4,7 @@
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
+using System.Text;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
@@ -137,7 +138,14 @@ public sealed class Converter : JsonConverter<ContentBlock>
                         break;
 
                     case "data":
-                        data = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray();
+                        if (!reader.ValueIsEscaped)
+                        {
+                            data = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray();
+                        }
+                        else
+                        {
+                            data = Encoding.UTF8.GetBytes(reader.GetString()!);
+                        }
                         break;
 
                     case "mimeType":

src/ModelContextProtocol.Core/Protocol/ResourceContents.cs

@@ -2,6 +2,7 @@
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Text;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
@@ -105,7 +106,14 @@ public sealed class Converter : JsonConverter<ResourceContents>
                         break;
 
                     case "blob":
-                        blob = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray();
+                        if (!reader.ValueIsEscaped)
+                        {
+                            blob = reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray();
+                        }
+                        else
+                        {
+                            blob = Encoding.UTF8.GetBytes(reader.GetString()!);
+                        }
                         break;
 
                     case "text":

tests/ModelContextProtocol.Tests/Protocol/ContentBlockTests.cs

@@ -290,4 +290,37 @@ public void AudioContentBlock_FromBytes_ThrowsForNullOrWhiteSpaceMimeType(string
     {
         Assert.ThrowsAny<ArgumentException>(() => AudioContentBlock.FromBytes((byte[])[1, 2, 3], mimeType!));
     }
+
+    [Fact]
+    public void ImageContentBlock_Deserialization_HandlesEscapedForwardSlashInBase64()
+    {
+        // Base64 uses '/' which some JSON encoders escape as '\/' (valid JSON).
+        // The converter must unescape before storing the base64 UTF-8 bytes.
+        byte[] originalBytes = [0xFF, 0xD8, 0xFF, 0xE0]; // sample bytes that produce '/' in base64
+        string base64 = Convert.ToBase64String(originalBytes); // "/9j/4A=="
+        Assert.Contains("/", base64);
+
+        // Simulate a JSON encoder that escapes '/' as '\/'
+        string json = $$"""{"type":"image","data":"{{base64.Replace("/", "\\/")}}","mimeType":"image/jpeg"}""";
+
+        var deserialized = JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions);
+        var image = Assert.IsType<ImageContentBlock>(deserialized);
+        Assert.Equal(base64, System.Text.Encoding.UTF8.GetString(image.Data.ToArray()));
+        Assert.Equal(originalBytes, image.DecodedData.ToArray());
+    }
+
+    [Fact]
+    public void AudioContentBlock_Deserialization_HandlesEscapedForwardSlashInBase64()
+    {
+        byte[] originalBytes = [0xFF, 0xD8, 0xFF, 0xE0];
+        string base64 = Convert.ToBase64String(originalBytes);
+        Assert.Contains("/", base64);
+
+        string json = $$"""{"type":"audio","data":"{{base64.Replace("/", "\\/")}}","mimeType":"audio/wav"}""";
+
+        var deserialized = JsonSerializer.Deserialize<ContentBlock>(json, McpJsonUtilities.DefaultOptions);
+        var audio = Assert.IsType<AudioContentBlock>(deserialized);
+        Assert.Equal(base64, System.Text.Encoding.UTF8.GetString(audio.Data.ToArray()));
+        Assert.Equal(originalBytes, audio.DecodedData.ToArray());
+    }
 }

tests/ModelContextProtocol.Tests/Protocol/ResourceContentsTests.cs

@@ -489,4 +489,22 @@ public static void BlobResourceContents_NullMimeType_OmittedFromJson()
 
         Assert.DoesNotContain("mimeType", json);
     }
+
+    [Fact]
+    public static void BlobResourceContents_Deserialization_HandlesEscapedForwardSlashInBase64()
+    {
+        // Base64 uses '/' which some JSON encoders escape as '\/' (valid JSON).
+        // The converter must unescape before storing the base64 UTF-8 bytes.
+        byte[] originalBytes = [0xFF, 0xD8, 0xFF, 0xE0]; // sample bytes that produce '/' in base64
+        string base64 = Convert.ToBase64String(originalBytes); // "/9j/4A=="
+        Assert.Contains("/", base64);
+
+        // Simulate a JSON encoder that escapes '/' as '\/'
+        string json = $$"""{"uri":"file:///test.bin","blob":"{{base64.Replace("/", "\\/")}}","mimeType":"application/octet-stream"}""";
+
+        var deserialized = JsonSerializer.Deserialize<ResourceContents>(json, McpJsonUtilities.DefaultOptions);
+        var blob = Assert.IsType<BlobResourceContents>(deserialized);
+        Assert.Equal(base64, System.Text.Encoding.UTF8.GetString(blob.Blob.ToArray()));
+        Assert.Equal(originalBytes, blob.DecodedData.ToArray());
+    }
 }