fix blob and content block data handling / transcoding

Author: Tyler-IN

src/ModelContextProtocol.Core/Protocol/BlobResourceContents.cs

@@ -55,7 +55,7 @@ public required string Blob
         set
         {
             _blob = value;
-            _blobUtf8 = System.Text.Encoding.UTF8.GetBytes(value);
+            _blobUtf8 = Encoding.UTF8.GetBytes(value);
             _decodedData = default; // Invalidate cache
         }
     }
@@ -73,7 +73,7 @@ public ReadOnlyMemory<byte> BlobUtf8
             ? _blob is null
                 ? _decodedData.IsEmpty
                     ? ReadOnlyMemory<byte>.Empty
-                    : EncodeToUtf8( _decodedData )
+                    : EncodeToUtf8(_decodedData)
                 : Encoding.UTF8.GetBytes(_blob)
             : _blobUtf8;
         set
@@ -98,6 +98,11 @@ private ReadOnlyMemory<byte> EncodeToUtf8(ReadOnlyMemory<byte> decodedData)
         }
     }
 
+    [JsonIgnore]
+    internal bool HasBlobUtf8 => !_blobUtf8.IsEmpty;
+
+    internal ReadOnlySpan<byte> GetBlobUtf8Span() => _blobUtf8.Span;
+
     /// <summary>
     /// Gets the decoded data represented by <see cref="BlobUtf8"/>.
     /// </summary>
@@ -118,12 +123,8 @@ public ReadOnlyMemory<byte> DecodedData
                     _decodedData = Convert.FromBase64String(_blob);
                     return _decodedData;
                 }
-#if NET
                 // Decode directly from UTF-8 base64 bytes without string intermediate
                 int maxLength = Base64.GetMaxDecodedFromUtf8Length(BlobUtf8.Length);
-#else
-                int maxLength = ((BlobUtf8.Length + 3) / 4) * 3;
-#endif
                 byte[] buffer = new byte[maxLength];
                 if (Base64.DecodeFromUtf8(BlobUtf8.Span, buffer, out _, out int bytesWritten) == System.Buffers.OperationStatus.Done)
                 {

src/ModelContextProtocol.Core/Protocol/ContentBlock.cs

@@ -1,4 +1,5 @@
 using System.Buffers;
+using System.Buffers.Text;
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
@@ -98,7 +99,7 @@ internal Converter(bool materializeUtf8TextContentBlocks) =>
             string? type = null;
             ReadOnlyMemory<byte>? utf8Text = null;
             string? name = null;
-            string? data = null;
+            ReadOnlyMemory<byte>? dataUtf8 = null;
             string? mimeType = null;
             string? uri = null;
             string? description = null;
@@ -141,7 +142,7 @@ internal Converter(bool materializeUtf8TextContentBlocks) =>
                         break;
 
                     case "data":
-                        data = reader.GetString();
+                        dataUtf8 = ReadUtf8StringValueAsBytes(ref reader);
                         break;
 
                     case "mimeType":
@@ -229,13 +230,13 @@ internal Converter(bool materializeUtf8TextContentBlocks) =>
 
                 "image" => new ImageContentBlock
                 {
-                    Data = data ?? throw new JsonException("Image data must be provided for 'image' type."),
+                    DataUtf8 = dataUtf8 ?? throw new JsonException("Image data must be provided for 'image' type."),
                     MimeType = mimeType ?? throw new JsonException("MIME type must be provided for 'image' type."),
                 },
 
                 "audio" => new AudioContentBlock
                 {
-                    Data = data ?? throw new JsonException("Audio data must be provided for 'audio' type."),
+                    DataUtf8 = dataUtf8 ?? throw new JsonException("Audio data must be provided for 'audio' type."),
                     MimeType = mimeType ?? throw new JsonException("MIME type must be provided for 'audio' type."),
                 },
 
@@ -277,7 +278,7 @@ internal Converter(bool materializeUtf8TextContentBlocks) =>
             return block;
         }
 
-        private static ReadOnlyMemory<byte> ReadUtf8StringValueAsBytes(ref Utf8JsonReader reader)
+        internal static ReadOnlyMemory<byte> ReadUtf8StringValueAsBytes(ref Utf8JsonReader reader)
         {
             if (reader.TokenType != JsonTokenType.String)
             {
@@ -488,12 +489,26 @@ public override void Write(Utf8JsonWriter writer, ContentBlock value, JsonSerial
                     break;
 
                 case ImageContentBlock imageContent:
-                    writer.WriteString("data", imageContent.Data);
+                    if (imageContent.HasDataUtf8)
+                    {
+                        writer.WriteString("data", imageContent.GetDataUtf8Span());
+                    }
+                    else
+                    {
+                        writer.WriteString("data", imageContent.Data);
+                    }
                     writer.WriteString("mimeType", imageContent.MimeType);
                     break;
 
                 case AudioContentBlock audioContent:
-                    writer.WriteString("data", audioContent.Data);
+                    if (audioContent.HasDataUtf8)
+                    {
+                        writer.WriteString("data", audioContent.GetDataUtf8Span());
+                    }
+                    else
+                    {
+                        writer.WriteString("data", audioContent.Data);
+                    }
                     writer.WriteString("mimeType", audioContent.MimeType);
                     break;
 
@@ -675,9 +690,9 @@ public static implicit operator Utf8TextContentBlock(TextContentBlock text)
 [DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class ImageContentBlock : ContentBlock
 {
-    private byte[]? _dataUtf8;
-    private byte[]? _decodedData;
-    private string _data = string.Empty;
+    private ReadOnlyMemory<byte> _dataUtf8;
+    private ReadOnlyMemory<byte> _decodedData;
+    private string? _data;
 
     /// <inheritdoc/>
     public override string Type => "image";
@@ -686,14 +701,16 @@ public sealed class ImageContentBlock : ContentBlock
     /// Gets or sets the base64-encoded image data.
     /// </summary>
     [JsonPropertyName("data")]
-    public required string Data
+    public string Data
     {
-        get => _data;
+        get => _data ??= !_dataUtf8.IsEmpty
+            ? Core.McpTextUtilities.GetStringFromUtf8(_dataUtf8.Span)
+            : string.Empty;
         set
         {
             _data = value;
-            _dataUtf8 = null;
-            _decodedData = null;
+            _dataUtf8 = System.Text.Encoding.UTF8.GetBytes(value);
+            _decodedData = default; // Invalidate cache
         }
     }
 
@@ -703,20 +720,54 @@ public required string Data
     [JsonIgnore]
     public ReadOnlyMemory<byte> DataUtf8
     {
-        get => _dataUtf8 ??= System.Text.Encoding.UTF8.GetBytes(Data);
+        get => _dataUtf8.IsEmpty
+            ? _data is null
+                ? ReadOnlyMemory<byte>.Empty
+                : System.Text.Encoding.UTF8.GetBytes(_data)
+            : _dataUtf8;
         set
         {
-            _dataUtf8 = value.Span.ToArray();
-            _data = System.Text.Encoding.UTF8.GetString(_dataUtf8);
-            _decodedData = null;
+            _data = null;
+            _dataUtf8 = value;
+            _decodedData = default; // Invalidate cache
         }
     }
 
     /// <summary>
-    /// Gets the decoded image data represented by <see cref="Data"/>.
+    /// Gets the decoded image data represented by <see cref="DataUtf8"/>.
     /// </summary>
+    /// <remarks>
+    /// Accessing this member will decode the value in <see cref="DataUtf8"/> and cache the result.
+    /// Subsequent accesses return the cached value unless <see cref="Data"/> or <see cref="DataUtf8"/> is modified.
+    /// </remarks>
     [JsonIgnore]
-    public ReadOnlyMemory<byte> DecodedData => _decodedData ??= Convert.FromBase64String(Data);
+    public ReadOnlyMemory<byte> DecodedData
+    {
+        get
+        {
+            if (_decodedData.IsEmpty)
+            {
+                if (_data is not null)
+                {
+                    _decodedData = Convert.FromBase64String(_data);
+                    return _decodedData;
+                }
+
+                int maxLength = Base64.GetMaxDecodedFromUtf8Length(DataUtf8.Length);
+                byte[] buffer = new byte[maxLength];
+                if (Base64.DecodeFromUtf8(DataUtf8.Span, buffer, out _, out int bytesWritten) == OperationStatus.Done)
+                {
+                    _decodedData = bytesWritten == maxLength ? buffer : buffer.AsMemory(0, bytesWritten).ToArray();
+                }
+                else
+                {
+                    throw new FormatException("Invalid base64 data");
+                }
+            }
+
+            return _decodedData;
+        }
+    }
 
     /// <summary>
     /// Gets or sets the MIME type (or "media type") of the content, specifying the format of the data.
@@ -727,6 +778,10 @@ public ReadOnlyMemory<byte> DataUtf8
     [JsonPropertyName("mimeType")]
     public required string MimeType { get; set; }
 
+    internal bool HasDataUtf8 => !_dataUtf8.IsEmpty;
+
+    internal ReadOnlySpan<byte> GetDataUtf8Span() => _dataUtf8.Span;
+
     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => $"MimeType = {MimeType}, Length = {DebuggerDisplayHelper.GetBase64LengthDisplay(Data)}";
 }
@@ -735,9 +790,9 @@ public ReadOnlyMemory<byte> DataUtf8
 [DebuggerDisplay("{DebuggerDisplay,nq}")]
 public sealed class AudioContentBlock : ContentBlock
 {
-    private byte[]? _dataUtf8;
-    private byte[]? _decodedData;
-    private string _data = string.Empty;
+    private ReadOnlyMemory<byte> _dataUtf8;
+    private ReadOnlyMemory<byte> _decodedData;
+    private string? _data;
 
     /// <inheritdoc/>
     public override string Type => "audio";
@@ -746,14 +801,16 @@ public sealed class AudioContentBlock : ContentBlock
     /// Gets or sets the base64-encoded audio data.
     /// </summary>
     [JsonPropertyName("data")]
-    public required string Data
+    public string Data
     {
-        get => _data;
+        get => _data ??= !_dataUtf8.IsEmpty
+            ? Core.McpTextUtilities.GetStringFromUtf8(_dataUtf8.Span)
+            : string.Empty;
         set
         {
             _data = value;
-            _dataUtf8 = null;
-            _decodedData = null;
+            _dataUtf8 = System.Text.Encoding.UTF8.GetBytes(value);
+            _decodedData = default; // Invalidate cache
         }
     }
 
@@ -763,20 +820,54 @@ public required string Data
     [JsonIgnore]
     public ReadOnlyMemory<byte> DataUtf8
     {
-        get => _dataUtf8 ??= System.Text.Encoding.UTF8.GetBytes(Data);
+        get => _dataUtf8.IsEmpty
+            ? _data is null
+                ? ReadOnlyMemory<byte>.Empty
+                : System.Text.Encoding.UTF8.GetBytes(_data)
+            : _dataUtf8;
         set
         {
-            _dataUtf8 = value.Span.ToArray();
-            _data = System.Text.Encoding.UTF8.GetString(_dataUtf8);
-            _decodedData = null;
+            _data = null;
+            _dataUtf8 = value;
+            _decodedData = default; // Invalidate cache
         }
     }
 
     /// <summary>
-    /// Gets the decoded audio data represented by <see cref="Data"/>.
+    /// Gets the decoded audio data represented by <see cref="DataUtf8"/>.
     /// </summary>
+    /// <remarks>
+    /// Accessing this member will decode the value in <see cref="DataUtf8"/> and cache the result.
+    /// Subsequent accesses return the cached value unless <see cref="Data"/> or <see cref="DataUtf8"/> is modified.
+    /// </remarks>
     [JsonIgnore]
-    public ReadOnlyMemory<byte> DecodedData => _decodedData ??= Convert.FromBase64String(Data);
+    public ReadOnlyMemory<byte> DecodedData
+    {
+        get
+        {
+            if (_decodedData.IsEmpty)
+            {
+                if (_data is not null)
+                {
+                    _decodedData = Convert.FromBase64String(_data);
+                    return _decodedData;
+                }
+
+                int maxLength = Base64.GetMaxDecodedFromUtf8Length(DataUtf8.Length);
+                byte[] buffer = new byte[maxLength];
+                if (Base64.DecodeFromUtf8(DataUtf8.Span, buffer, out _, out int bytesWritten) == OperationStatus.Done)
+                {
+                    _decodedData = bytesWritten == maxLength ? buffer : buffer.AsMemory(0, bytesWritten).ToArray();
+                }
+                else
+                {
+                    throw new FormatException("Invalid base64 data");
+                }
+            }
+
+            return _decodedData;
+        }
+    }
 
     /// <summary>
     /// Gets or sets the MIME type (or "media type") of the content, specifying the format of the data.
@@ -787,6 +878,10 @@ public ReadOnlyMemory<byte> DataUtf8
     [JsonPropertyName("mimeType")]
     public required string MimeType { get; set; }
 
+    internal bool HasDataUtf8 => !_dataUtf8.IsEmpty;
+
+    internal ReadOnlySpan<byte> GetDataUtf8Span() => _dataUtf8.Span;
+
     [DebuggerBrowsable(DebuggerBrowsableState.Never)]
     private string DebuggerDisplay => $"MimeType = {MimeType}, Length = {DebuggerDisplayHelper.GetBase64LengthDisplay(Data)}";
 }

src/ModelContextProtocol.Core/Protocol/ResourceContents.cs

@@ -78,7 +78,7 @@ public class Converter : JsonConverter<ResourceContents>
 
             string? uri = null;
             string? mimeType = null;
-            string? blob = null;
+            ReadOnlyMemory<byte>? blobUtf8 = null;
             string? text = null;
             JsonObject? meta = null;
 
@@ -104,7 +104,7 @@ public class Converter : JsonConverter<ResourceContents>
                         break;
 
                     case "blob":
-                        blob = reader.GetString();
+                        blobUtf8 = ContentBlock.Converter.ReadUtf8StringValueAsBytes(ref reader);
                         break;
 
                     case "text":
@@ -121,13 +121,13 @@ public class Converter : JsonConverter<ResourceContents>
                 }
             }
 
-            if (blob is not null)
+            if (blobUtf8 is not null)
             {
                 return new BlobResourceContents
                 {
                     Uri = uri ?? string.Empty,
                     MimeType = mimeType,
-                    Blob = blob,
+                    BlobUtf8 = blobUtf8.Value,
                     Meta = meta,
                 };
             }
@@ -162,7 +162,14 @@ public override void Write(Utf8JsonWriter writer, ResourceContents value, JsonSe
             Debug.Assert(value is BlobResourceContents or TextResourceContents);
             if (value is BlobResourceContents blobResource)
             {
-                writer.WriteString("blob", blobResource.Blob);
+                if (blobResource.HasBlobUtf8)
+                {
+                    writer.WriteString("blob", blobResource.GetBlobUtf8Span());
+                }
+                else
+                {
+                    writer.WriteString("blob", blobResource.Blob);
+                }
             }
             else if (value is TextResourceContents textResource)
             {