Use ReadOnlyMemory<byte> for binary data to eliminate UTF-16 transcoding

samples/EverythingServer/Resources/SimpleResourceType.cs

@@ -31,7 +31,7 @@ public static ResourceContents TemplateResource(RequestContext<ReadResourceReque
             } :
             new BlobResourceContents
             {
-                Blob = resource.Description!,
+                Blob = System.Text.Encoding.UTF8.GetBytes(resource.Description!),
                 MimeType = resource.MimeType,
                 Uri = resource.Uri,
             };

samples/EverythingServer/Tools/AnnotatedMessageTool.cs

@@ -41,7 +41,7 @@ public static IEnumerable<ContentBlock> AnnotatedMessage(MessageType messageType
         {
             contents.Add(new ImageContentBlock
             {
-                Data = TinyImageTool.MCP_TINY_IMAGE.Split(",").Last(),
+                Data = System.Text.Encoding.UTF8.GetBytes(TinyImageTool.MCP_TINY_IMAGE.Split(",").Last()),
                 MimeType = "image/png",
                 Annotations = new() { Audience = [Role.User], Priority = 0.5f }
             });

src/ModelContextProtocol.Core/AIContentExtensions.cs

@@ -264,9 +264,9 @@ public static IList<PromptMessage> ToPromptMessages(this ChatMessage chatMessage
         {
             TextContentBlock textContent => new TextContent(textContent.Text),
 
-            ImageContentBlock imageContent => new DataContent(Convert.FromBase64String(imageContent.Data), imageContent.MimeType),
+            ImageContentBlock imageContent => new DataContent(imageContent.DecodedData, imageContent.MimeType),
 
-            AudioContentBlock audioContent => new DataContent(Convert.FromBase64String(audioContent.Data), audioContent.MimeType),
+            AudioContentBlock audioContent => new DataContent(audioContent.DecodedData, audioContent.MimeType),
 
             EmbeddedResourceBlock resourceContent => resourceContent.Resource.ToAIContent(),
 
@@ -307,7 +307,7 @@ public static AIContent ToAIContent(this ResourceContents content)
 
         AIContent ac = content switch
         {
-            BlobResourceContents blobResource => new DataContent(Convert.FromBase64String(blobResource.Blob), blobResource.MimeType ?? "application/octet-stream"),
+            BlobResourceContents blobResource => new DataContent(blobResource.Data, blobResource.MimeType ?? "application/octet-stream"),
             TextResourceContents textResource => new TextContent(textResource.Text),
             _ => throw new NotSupportedException($"Resource type '{content.GetType().Name}' is not supported.")
         };
@@ -380,21 +380,21 @@ public static ContentBlock ToContentBlock(this AIContent content)
 
             DataContent dataContent when dataContent.HasTopLevelMediaType("image") => new ImageContentBlock
             {
-                Data = dataContent.Base64Data.ToString(),
+                Data = System.Text.Encoding.UTF8.GetBytes(dataContent.Base64Data.ToString()),
                 MimeType = dataContent.MediaType,
             },
 
             DataContent dataContent when dataContent.HasTopLevelMediaType("audio") => new AudioContentBlock
             {
-                Data = dataContent.Base64Data.ToString(),
+                Data = System.Text.Encoding.UTF8.GetBytes(dataContent.Base64Data.ToString()),
                 MimeType = dataContent.MediaType,
             },
 
             DataContent dataContent => new EmbeddedResourceBlock
             {
                 Resource = new BlobResourceContents
                 {
-                    Blob = dataContent.Base64Data.ToString(),
+                    Blob = System.Text.Encoding.UTF8.GetBytes(dataContent.Base64Data.ToString()),
                     MimeType = dataContent.MediaType,
                     Uri = string.Empty,
                 }

src/ModelContextProtocol.Core/Protocol/BlobResourceContents.cs

@@ -1,3 +1,5 @@
+using System.Buffers.Text;
+using System.Runtime.InteropServices;
 using System.Text.Json.Serialization;
 
 namespace ModelContextProtocol.Protocol;
@@ -8,8 +10,8 @@ namespace ModelContextProtocol.Protocol;
 /// <remarks>
 /// <para>
 /// <see cref="BlobResourceContents"/> is used when binary data needs to be exchanged through
-/// the Model Context Protocol. The binary data is represented as a base64-encoded string
-/// in the <see cref="Blob"/> property.
+/// the Model Context Protocol. The binary data is represented as base64-encoded UTF-8 bytes
+/// in the <see cref="Blob"/> property, providing a zero-copy representation of the wire payload.
 /// </para>
 /// <para>
 /// This class inherits from <see cref="ResourceContents"/>, which also has a sibling implementation
@@ -22,9 +24,58 @@ namespace ModelContextProtocol.Protocol;
 /// </remarks>
 public sealed class BlobResourceContents : ResourceContents
 {
+    private byte[]? _decodedData;
+    private ReadOnlyMemory<byte> _blob;
+
     /// <summary>
-    /// Gets or sets the base64-encoded string representing the binary data of the item.
+    /// Gets or sets the base64-encoded UTF-8 bytes representing the binary data of the item.
     /// </summary>
+    /// <remarks>
+    /// This is a zero-copy representation of the wire payload of this item. Setting this value will invalidate any cached value of <see cref="Data"/>.
+    /// </remarks>
     [JsonPropertyName("blob")]
-    public required string Blob { get; set; }
+    public required ReadOnlyMemory<byte> Blob
+    {
+        get => _blob;
+        set
+        {
+            _blob = value;
+            _decodedData = null; // Invalidate cache
+        }
+    }
+
+    /// <summary>
+    /// Gets the decoded data represented by <see cref="Blob"/>.
+    /// </summary>
+    /// <remarks>
+    /// Accessing this member will decode the value in <see cref="Blob"/> and cache the result.
+    /// Subsequent accesses return the cached value unless <see cref="Blob"/> is modified.
+    /// </remarks>
+    [JsonIgnore]
+    public ReadOnlyMemory<byte> Data
+    {
+        get
+        {
+            if (_decodedData is null)
+            {
+#if NET
+                // Decode directly from UTF-8 base64 bytes without string intermediate
+                int maxLength = Base64.GetMaxDecodedFromUtf8Length(Blob.Length);
+                byte[] buffer = new byte[maxLength];
+                if (Base64.DecodeFromUtf8(Blob.Span, buffer, out _, out int bytesWritten) == System.Buffers.OperationStatus.Done)
+                {
+                    _decodedData = bytesWritten == maxLength ? buffer : buffer.AsMemory(0, bytesWritten).ToArray();
+                }
+                else
+                {
+                    throw new FormatException("Invalid base64 data");
+                }
+#else
+                byte[] array = MemoryMarshal.TryGetArray(Blob, out ArraySegment<byte> segment) && segment.Offset == 0 && segment.Count == segment.Array!.Length ? segment.Array : Blob.ToArray();
+                _decodedData = Convert.FromBase64String(System.Text.Encoding.UTF8.GetString(array));
+#endif
+            }
+            return _decodedData;
+        }
+    }
 }

src/ModelContextProtocol.Core/Protocol/ContentBlock.cs

@@ -1,6 +1,9 @@
+using System.Buffers;
+using System.Buffers.Text;
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
+using System.Runtime.InteropServices;
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using System.Text.Json.Serialization;
@@ -87,7 +90,7 @@ public class Converter : JsonConverter<ContentBlock>
             string? type = null;
             string? text = null;
             string? name = null;
-            string? data = null;
+            ReadOnlyMemory<byte>? data = null;
             string? mimeType = null;
             string? uri = null;
             string? description = null;
@@ -128,7 +131,15 @@ public class Converter : JsonConverter<ContentBlock>
                         break;
 
                     case "data":
-                        data = reader.GetString();
+                        // Read the base64-encoded UTF-8 bytes directly without string allocation
+                        if (reader.HasValueSequence)
+                        {
+                            data = reader.ValueSequence.ToArray();
+                        }
+                        else
+                        {
+                            data = reader.ValueSpan.ToArray();
+                        }
                         break;
 
                     case "mimeType":
@@ -279,12 +290,14 @@ public override void Write(Utf8JsonWriter writer, ContentBlock value, JsonSerial
                     break;
 
                 case ImageContentBlock imageContent:
-                    writer.WriteString("data", imageContent.Data);
+                    // Write the UTF-8 bytes directly as a string value
+                    writer.WriteString("data", imageContent.Data.Span);
                     writer.WriteString("mimeType", imageContent.MimeType);
                     break;
 
                 case AudioContentBlock audioContent:
-                    writer.WriteString("data", audioContent.Data);
+                    // Write the UTF-8 bytes directly as a string value
+                    writer.WriteString("data", audioContent.Data.Span);
                     writer.WriteString("mimeType", audioContent.MimeType);
                     break;
 
@@ -371,14 +384,63 @@ public sealed class TextContentBlock : ContentBlock
 /// <summary>Represents an image provided to or from an LLM.</summary>
 public sealed class ImageContentBlock : ContentBlock
 {
+    private byte[]? _decodedData;
+    private ReadOnlyMemory<byte> _data;
+
     /// <inheritdoc/>
     public override string Type => "image";
 
     /// <summary>
-    /// Gets or sets the base64-encoded image data.
+    /// Gets or sets the base64-encoded UTF-8 bytes representing the image data.
     /// </summary>
+    /// <remarks>
+    /// This is a zero-copy representation of the wire payload of this item. Setting this value will invalidate any cached value of <see cref="DecodedData"/>.
+    /// </remarks>
     [JsonPropertyName("data")]
-    public required string Data { get; set; }
+    public required ReadOnlyMemory<byte> Data
+    {
+        get => _data;
+        set
+        {
+            _data = value;
+            _decodedData = null; // Invalidate cache
+        }
+    }
+
+    /// <summary>
+    /// Gets the decoded image data represented by <see cref="Data"/>.
+    /// </summary>
+    /// <remarks>
+    /// Accessing this member will decode the value in <see cref="Data"/> and cache the result.
+    /// Subsequent accesses return the cached value unless <see cref="Data"/> is modified.
+    /// </remarks>
+    [JsonIgnore]
+    public ReadOnlyMemory<byte> DecodedData
+    {
+        get
+        {
+            if (_decodedData is null)
+            {
+#if NET
+                // Decode directly from UTF-8 base64 bytes without string intermediate
+                int maxLength = Base64.GetMaxDecodedFromUtf8Length(Data.Length);
+                byte[] buffer = new byte[maxLength];
+                if (Base64.DecodeFromUtf8(Data.Span, buffer, out _, out int bytesWritten) == System.Buffers.OperationStatus.Done)
+                {
+                    _decodedData = bytesWritten == maxLength ? buffer : buffer.AsMemory(0, bytesWritten).ToArray();
+                }
+                else
+                {
+                    throw new FormatException("Invalid base64 data");
+                }
+#else
+                byte[] array = MemoryMarshal.TryGetArray(Data, out ArraySegment<byte> segment) && segment.Offset == 0 && segment.Count == segment.Array!.Length ? segment.Array : Data.ToArray();
+                _decodedData = Convert.FromBase64String(System.Text.Encoding.UTF8.GetString(array));
+#endif
+            }
+            return _decodedData;
+        }
+    }
 
     /// <summary>
     /// Gets or sets the MIME type (or "media type") of the content, specifying the format of the data.
@@ -393,14 +455,63 @@ public sealed class ImageContentBlock : ContentBlock
 /// <summary>Represents audio provided to or from an LLM.</summary>
 public sealed class AudioContentBlock : ContentBlock
 {
+    private byte[]? _decodedData;
+    private ReadOnlyMemory<byte> _data;
+
     /// <inheritdoc/>
     public override string Type => "audio";
 
     /// <summary>
-    /// Gets or sets the base64-encoded audio data.
+    /// Gets or sets the base64-encoded UTF-8 bytes representing the audio data.
     /// </summary>
+    /// <remarks>
+    /// This is a zero-copy representation of the wire payload of this item. Setting this value will invalidate any cached value of <see cref="DecodedData"/>.
+    /// </remarks>
     [JsonPropertyName("data")]
-    public required string Data { get; set; }
+    public required ReadOnlyMemory<byte> Data
+    {
+        get => _data;
+        set
+        {
+            _data = value;
+            _decodedData = null; // Invalidate cache
+        }
+    }
+
+    /// <summary>
+    /// Gets the decoded audio data represented by <see cref="Data"/>.
+    /// </summary>
+    /// <remarks>
+    /// Accessing this member will decode the value in <see cref="Data"/> and cache the result.
+    /// Subsequent accesses return the cached value unless <see cref="Data"/> is modified.
+    /// </remarks>
+    [JsonIgnore]
+    public ReadOnlyMemory<byte> DecodedData
+    {
+        get
+        {
+            if (_decodedData is null)
+            {
+#if NET
+                // Decode directly from UTF-8 base64 bytes without string intermediate
+                int maxLength = Base64.GetMaxDecodedFromUtf8Length(Data.Length);
+                byte[] buffer = new byte[maxLength];
+                if (Base64.DecodeFromUtf8(Data.Span, buffer, out _, out int bytesWritten) == System.Buffers.OperationStatus.Done)
+                {
+                    _decodedData = bytesWritten == maxLength ? buffer : buffer.AsMemory(0, bytesWritten).ToArray();
+                }
+                else
+                {
+                    throw new FormatException("Invalid base64 data");
+                }
+#else
+                byte[] array = MemoryMarshal.TryGetArray(Data, out ArraySegment<byte> segment) && segment.Offset == 0 && segment.Count == segment.Array!.Length ? segment.Array : Data.ToArray();
+                _decodedData = Convert.FromBase64String(System.Text.Encoding.UTF8.GetString(array));
+#endif
+            }
+            return _decodedData;
+        }
+    }
 
     /// <summary>
     /// Gets or sets the MIME type (or "media type") of the content, specifying the format of the data.

src/ModelContextProtocol.Core/Protocol/ResourceContents.cs

@@ -1,3 +1,4 @@
+using System.Buffers;
 using System.ComponentModel;
 using System.Diagnostics;
 using System.Diagnostics.CodeAnalysis;
@@ -78,7 +79,7 @@ public class Converter : JsonConverter<ResourceContents>
 
             string? uri = null;
             string? mimeType = null;
-            string? blob = null;
+            ReadOnlyMemory<byte>? blob = null;
             string? text = null;
             JsonObject? meta = null;
 
@@ -104,7 +105,15 @@ public class Converter : JsonConverter<ResourceContents>
                         break;
 
                     case "blob":
-                        blob = reader.GetString();
+                        // Read the base64-encoded UTF-8 bytes directly without string allocation
+                        if (reader.HasValueSequence)
+                        {
+                            blob = reader.ValueSequence.ToArray();
+                        }
+                        else
+                        {
+                            blob = reader.ValueSpan.ToArray();
+                        }
                         break;
 
                     case "text":
@@ -127,7 +136,7 @@ public class Converter : JsonConverter<ResourceContents>
                 {
                     Uri = uri ?? string.Empty,
                     MimeType = mimeType,
-                    Blob = blob,
+                    Blob = blob.Value,
                     Meta = meta,
                 };
             }
@@ -162,7 +171,8 @@ 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);
+                // Write the UTF-8 bytes directly as a string value
+                writer.WriteString("blob", blobResource.Blob.Span);
             }
             else if (value is TextResourceContents textResource)
             {