Skip to content

Commit f1af251

Browse files
eiriktsarpaliseiriktsarpalis
authored
Allow JsonSerializerOptions parameters for user-defined and inputs and hardcode everything else to the source generator. (#182)
* Allow user-defined JsonSerializerOptions for user-defined and inputs and hardcode everything else to the source generator. * Add validation for user-defined JsonSerializerOptions. * Remove out of date comment. * Address feedback and add tests
1 parent 4b38d3e commit f1af251

36 files changed

+632
-372
lines changed

‎src/ModelContextProtocol/Client/McpClient.cs

+22-19
Original file line numberDiff line numberDiff line change
@@ -40,12 +40,14 @@ public McpClient(IClientTransport clientTransport, McpClientOptions options, Mcp
4040
throw new InvalidOperationException($"Sampling capability was set but it did not provide a handler.");
4141
}
4242

43-
SetRequestHandler<CreateMessageRequestParams, CreateMessageResult>(
43+
SetRequestHandler(
4444
RequestMethods.SamplingCreateMessage,
4545
(request, cancellationToken) => samplingHandler(
4646
request,
4747
request?.Meta?.ProgressToken is { } token ? new TokenProgress(this, token) : NullProgress.Instance,
48-
cancellationToken));
48+
cancellationToken),
49+
McpJsonUtilities.JsonContext.Default.CreateMessageRequestParams,
50+
McpJsonUtilities.JsonContext.Default.CreateMessageResult);
4951
}
5052

5153
if (options.Capabilities?.Roots is { } rootsCapability)
@@ -55,9 +57,11 @@ public McpClient(IClientTransport clientTransport, McpClientOptions options, Mcp
5557
throw new InvalidOperationException($"Roots capability was set but it did not provide a handler.");
5658
}
5759

58-
SetRequestHandler<ListRootsRequestParams, ListRootsResult>(
60+
SetRequestHandler(
5961
RequestMethods.RootsList,
60-
(request, cancellationToken) => rootsHandler(request, cancellationToken));
62+
rootsHandler,
63+
McpJsonUtilities.JsonContext.Default.ListRootsRequestParams,
64+
McpJsonUtilities.JsonContext.Default.ListRootsResult);
6165
}
6266
}
6367

@@ -88,21 +92,20 @@ public async Task ConnectAsync(CancellationToken cancellationToken = default)
8892
using var initializationCts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
8993
initializationCts.CancelAfter(_options.InitializationTimeout);
9094

91-
try
92-
{
93-
// Send initialize request
94-
var initializeResponse = await SendRequestAsync<InitializeResult>(
95-
new JsonRpcRequest
96-
{
97-
Method = RequestMethods.Initialize,
98-
Params = new InitializeRequestParams()
99-
{
100-
ProtocolVersion = _options.ProtocolVersion,
101-
Capabilities = _options.Capabilities ?? new ClientCapabilities(),
102-
ClientInfo = _options.ClientInfo
103-
}
104-
},
105-
initializationCts.Token).ConfigureAwait(false);
95+
try
96+
{
97+
// Send initialize request
98+
var initializeResponse = await this.SendRequestAsync(
99+
RequestMethods.Initialize,
100+
new InitializeRequestParams
101+
{
102+
ProtocolVersion = _options.ProtocolVersion,
103+
Capabilities = _options.Capabilities ?? new ClientCapabilities(),
104+
ClientInfo = _options.ClientInfo
105+
},
106+
McpJsonUtilities.JsonContext.Default.InitializeRequestParams,
107+
McpJsonUtilities.JsonContext.Default.InitializeResult,
108+
cancellationToken: initializationCts.Token).ConfigureAwait(false);
106109

107110
// Store server information
108111
_logger.ServerCapabilitiesReceived(EndpointName,

‎src/ModelContextProtocol/Client/McpClientExtensions.cs

+136-114
Large diffs are not rendered by default.

‎src/ModelContextProtocol/Client/McpClientPrompt.cs

+4-1
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
11
using ModelContextProtocol.Protocol.Types;
2+
using System.Text.Json;
23

34
namespace ModelContextProtocol.Client;
45

@@ -20,17 +21,19 @@ internal McpClientPrompt(IMcpClient client, Prompt prompt)
2021
/// Retrieves a specific prompt with optional arguments.
2122
/// </summary>
2223
/// <param name="arguments">Optional arguments for the prompt</param>
24+
/// <param name="serializerOptions">The serialization options governing argument serialization.</param>
2325
/// <param name="cancellationToken">A token to cancel the operation.</param>
2426
/// <returns>A task containing the prompt's content and messages.</returns>
2527
public async ValueTask<GetPromptResult> GetAsync(
2628
IEnumerable<KeyValuePair<string, object?>>? arguments = null,
29+
JsonSerializerOptions? serializerOptions = null,
2730
CancellationToken cancellationToken = default)
2831
{
2932
IReadOnlyDictionary<string, object?>? argDict =
3033
arguments as IReadOnlyDictionary<string, object?> ??
3134
arguments?.ToDictionary();
3235

33-
return await _client.GetPromptAsync(ProtocolPrompt.Name, argDict, cancellationToken).ConfigureAwait(false);
36+
return await _client.GetPromptAsync(ProtocolPrompt.Name, argDict, serializerOptions, cancellationToken: cancellationToken).ConfigureAwait(false);
3437
}
3538

3639
/// <summary>Gets the name of the prompt.</summary>

‎src/ModelContextProtocol/Client/McpClientTool.cs

+4-3
Original file line numberDiff line numberDiff line change
@@ -10,10 +10,11 @@ public sealed class McpClientTool : AIFunction
1010
{
1111
private readonly IMcpClient _client;
1212

13-
internal McpClientTool(IMcpClient client, Tool tool)
13+
internal McpClientTool(IMcpClient client, Tool tool, JsonSerializerOptions serializerOptions)
1414
{
1515
_client = client;
1616
ProtocolTool = tool;
17+
JsonSerializerOptions = serializerOptions;
1718
}
1819

1920
/// <summary>Gets the protocol <see cref="Tool"/> type for this instance.</summary>
@@ -29,7 +30,7 @@ internal McpClientTool(IMcpClient client, Tool tool)
2930
public override JsonElement JsonSchema => ProtocolTool.InputSchema;
3031

3132
/// <inheritdoc/>
32-
public override JsonSerializerOptions JsonSerializerOptions => McpJsonUtilities.DefaultOptions;
33+
public override JsonSerializerOptions JsonSerializerOptions { get; }
3334

3435
/// <inheritdoc/>
3536
protected async override Task<object?> InvokeCoreAsync(
@@ -39,7 +40,7 @@ internal McpClientTool(IMcpClient client, Tool tool)
3940
arguments as IReadOnlyDictionary<string, object?> ??
4041
arguments.ToDictionary();
4142

42-
CallToolResponse result = await _client.CallToolAsync(ProtocolTool.Name, argDict, cancellationToken).ConfigureAwait(false);
43+
CallToolResponse result = await _client.CallToolAsync(ProtocolTool.Name, argDict, JsonSerializerOptions, cancellationToken: cancellationToken).ConfigureAwait(false);
4344
return JsonSerializer.SerializeToElement(result, McpJsonUtilities.JsonContext.Default.CallToolResponse);
4445
}
4546
}

‎src/ModelContextProtocol/IMcpEndpoint.cs

+2-3
Original file line numberDiff line numberDiff line change
@@ -5,12 +5,11 @@ namespace ModelContextProtocol;
55
/// <summary>Represents a client or server MCP endpoint.</summary>
66
public interface IMcpEndpoint : IAsyncDisposable
77
{
8-
/// <summary>Sends a generic JSON-RPC request to the connected endpoint.</summary>
9-
/// <typeparam name="TResult">The expected response type.</typeparam>
8+
/// <summary>Sends a JSON-RPC request to the connected endpoint.</summary>
109
/// <param name="request">The JSON-RPC request to send.</param>
1110
/// <param name="cancellationToken">A token to cancel the operation.</param>
1211
/// <returns>A task containing the client's response.</returns>
13-
Task<TResult> SendRequestAsync<TResult>(JsonRpcRequest request, CancellationToken cancellationToken = default) where TResult : class;
12+
Task<JsonRpcResponse> SendRequestAsync(JsonRpcRequest request, CancellationToken cancellationToken = default);
1413

1514
/// <summary>Sends a message to the connected endpoint.</summary>
1615
/// <param name="message">The message.</param>

‎src/ModelContextProtocol/Logging/Log.cs

-3
Original file line numberDiff line numberDiff line change
@@ -77,9 +77,6 @@ internal static partial class Log
7777
[LoggerMessage(Level = LogLevel.Information, Message = "Request response received for {endpointName} with method {method}")]
7878
internal static partial void RequestResponseReceived(this ILogger logger, string endpointName, string method);
7979

80-
[LoggerMessage(Level = LogLevel.Error, Message = "Request response type conversion error for {endpointName} with method {method}: expected {expectedType}")]
81-
internal static partial void RequestResponseTypeConversionError(this ILogger logger, string endpointName, string method, Type expectedType);
82-
8380
[LoggerMessage(Level = LogLevel.Error, Message = "Request invalid response type for {endpointName} with method {method}")]
8481
internal static partial void RequestInvalidResponseType(this ILogger logger, string endpointName, string method);
8582

‎src/ModelContextProtocol/McpEndpointExtensions.cs

+137-3
Original file line numberDiff line numberDiff line change
@@ -1,13 +1,147 @@
11
using ModelContextProtocol.Protocol.Messages;
22
using ModelContextProtocol.Utils;
3+
using ModelContextProtocol.Utils.Json;
4+
using System.Text.Json;
5+
using System.Text.Json.Nodes;
6+
using System.Text.Json.Serialization.Metadata;
37

48
namespace ModelContextProtocol;
59

610
/// <summary>Provides extension methods for interacting with an <see cref="IMcpEndpoint"/>.</summary>
711
public static class McpEndpointExtensions
812
{
13+
/// <summary>
14+
/// Sends a JSON-RPC request and attempts to deserialize the result to <typeparamref name="TResult"/>.
15+
/// </summary>
16+
/// <typeparam name="TParameters">The type of the request parameters to serialize from.</typeparam>
17+
/// <typeparam name="TResult">The type of the result to deserialize to.</typeparam>
18+
/// <param name="endpoint">The MCP client or server instance.</param>
19+
/// <param name="method">The JSON-RPC method name to invoke.</param>
20+
/// <param name="parameters">Object representing the request parameters.</param>
21+
/// <param name="requestId">The request id for the request.</param>
22+
/// <param name="serializerOptions">The options governing request serialization.</param>
23+
/// <param name="cancellationToken">A token to cancel the operation.</param>
24+
/// <returns>A task that represents the asynchronous operation. The task result contains the deserialized result.</returns>
25+
public static Task<TResult> SendRequestAsync<TParameters, TResult>(
26+
this IMcpEndpoint endpoint,
27+
string method,
28+
TParameters parameters,
29+
JsonSerializerOptions? serializerOptions = null,
30+
RequestId? requestId = null,
31+
CancellationToken cancellationToken = default)
32+
where TResult : notnull
33+
{
34+
serializerOptions ??= McpJsonUtilities.DefaultOptions;
35+
serializerOptions.MakeReadOnly();
36+
37+
JsonTypeInfo<TParameters> paramsTypeInfo = serializerOptions.GetTypeInfo<TParameters>();
38+
JsonTypeInfo<TResult> resultTypeInfo = serializerOptions.GetTypeInfo<TResult>();
39+
return SendRequestAsync(endpoint, method, parameters, paramsTypeInfo, resultTypeInfo, requestId, cancellationToken);
40+
}
41+
42+
/// <summary>
43+
/// Sends a JSON-RPC request and attempts to deserialize the result to <typeparamref name="TResult"/>.
44+
/// </summary>
45+
/// <typeparam name="TParameters">The type of the request parameters to serialize from.</typeparam>
46+
/// <typeparam name="TResult">The type of the result to deserialize to.</typeparam>
47+
/// <param name="endpoint">The MCP client or server instance.</param>
48+
/// <param name="method">The JSON-RPC method name to invoke.</param>
49+
/// <param name="parameters">Object representing the request parameters.</param>
50+
/// <param name="parametersTypeInfo">The type information for request parameter serialization.</param>
51+
/// <param name="resultTypeInfo">The type information for request parameter deserialization.</param>
52+
/// <param name="requestId">The request id for the request.</param>
53+
/// <param name="cancellationToken">A token to cancel the operation.</param>
54+
/// <returns>A task that represents the asynchronous operation. The task result contains the deserialized result.</returns>
55+
internal static async Task<TResult> SendRequestAsync<TParameters, TResult>(
56+
this IMcpEndpoint endpoint,
57+
string method,
58+
TParameters parameters,
59+
JsonTypeInfo<TParameters> parametersTypeInfo,
60+
JsonTypeInfo<TResult> resultTypeInfo,
61+
RequestId? requestId = null,
62+
CancellationToken cancellationToken = default)
63+
where TResult : notnull
64+
{
65+
Throw.IfNull(endpoint);
66+
Throw.IfNullOrWhiteSpace(method);
67+
Throw.IfNull(parametersTypeInfo);
68+
Throw.IfNull(resultTypeInfo);
69+
70+
JsonRpcRequest jsonRpcRequest = new()
71+
{
72+
Method = method,
73+
Params = JsonSerializer.SerializeToNode(parameters, parametersTypeInfo),
74+
};
75+
76+
if (requestId is { } id)
77+
{
78+
jsonRpcRequest.Id = id;
79+
}
80+
81+
JsonRpcResponse response = await endpoint.SendRequestAsync(jsonRpcRequest, cancellationToken).ConfigureAwait(false);
82+
return JsonSerializer.Deserialize(response.Result, resultTypeInfo) ?? throw new JsonException("Unexpected JSON result in response.");
83+
}
84+
85+
/// <summary>
86+
/// Sends a notification to the server with parameters.
87+
/// </summary>
88+
/// <param name="client">The client.</param>
89+
/// <param name="method">The notification method name.</param>
90+
/// <param name="cancellationToken">A token to cancel the operation.</param>
91+
public static Task SendNotificationAsync(this IMcpEndpoint client, string method, CancellationToken cancellationToken = default)
92+
{
93+
Throw.IfNull(client);
94+
Throw.IfNullOrWhiteSpace(method);
95+
return client.SendMessageAsync(new JsonRpcNotification { Method = method }, cancellationToken);
96+
}
97+
98+
/// <summary>
99+
/// Sends a notification to the server with parameters.
100+
/// </summary>
101+
/// <param name="endpoint">The MCP client or server instance.</param>
102+
/// <param name="method">The JSON-RPC method name to invoke.</param>
103+
/// <param name="parameters">Object representing the request parameters.</param>
104+
/// <param name="serializerOptions">The options governing request serialization.</param>
105+
/// <param name="cancellationToken">A token to cancel the operation.</param>
106+
public static Task SendNotificationAsync<TParameters>(
107+
this IMcpEndpoint endpoint,
108+
string method,
109+
TParameters parameters,
110+
JsonSerializerOptions? serializerOptions = null,
111+
CancellationToken cancellationToken = default)
112+
{
113+
serializerOptions ??= McpJsonUtilities.DefaultOptions;
114+
serializerOptions.MakeReadOnly();
115+
116+
JsonTypeInfo<TParameters> parametersTypeInfo = serializerOptions.GetTypeInfo<TParameters>();
117+
return SendNotificationAsync(endpoint, method, parameters, parametersTypeInfo, cancellationToken);
118+
}
119+
120+
/// <summary>
121+
/// Sends a notification to the server with parameters.
122+
/// </summary>
123+
/// <param name="endpoint">The MCP client or server instance.</param>
124+
/// <param name="method">The JSON-RPC method name to invoke.</param>
125+
/// <param name="parameters">Object representing the request parameters.</param>
126+
/// <param name="parametersTypeInfo">The type information for request parameter serialization.</param>
127+
/// <param name="cancellationToken">A token to cancel the operation.</param>
128+
internal static Task SendNotificationAsync<TParameters>(
129+
this IMcpEndpoint endpoint,
130+
string method,
131+
TParameters parameters,
132+
JsonTypeInfo<TParameters> parametersTypeInfo,
133+
CancellationToken cancellationToken = default)
134+
{
135+
Throw.IfNull(endpoint);
136+
Throw.IfNullOrWhiteSpace(method);
137+
Throw.IfNull(parametersTypeInfo);
138+
139+
JsonNode? parametersJson = JsonSerializer.SerializeToNode(parameters, parametersTypeInfo);
140+
return endpoint.SendMessageAsync(new JsonRpcNotification { Method = method, Params = parametersJson }, cancellationToken);
141+
}
142+
9143
/// <summary>Notifies the connected endpoint of progress.</summary>
10-
/// <param name="endpoint">The endpoint issueing the notification.</param>
144+
/// <param name="endpoint">The endpoint issuing the notification.</param>
11145
/// <param name="progressToken">The <see cref="ProgressToken"/> identifying the operation.</param>
12146
/// <param name="progress">The progress update to send.</param>
13147
/// <param name="cancellationToken">A token to cancel the operation.</param>
@@ -24,11 +158,11 @@ public static Task NotifyProgressAsync(
24158
return endpoint.SendMessageAsync(new JsonRpcNotification()
25159
{
26160
Method = NotificationMethods.ProgressNotification,
27-
Params = new ProgressNotification()
161+
Params = JsonSerializer.SerializeToNode(new ProgressNotification
28162
{
29163
ProgressToken = progressToken,
30164
Progress = progress,
31-
},
165+
}, McpJsonUtilities.JsonContext.Default.ProgressNotification),
32166
}, cancellationToken);
33167
}
34168
}

‎src/ModelContextProtocol/Protocol/Messages/JsonRpcNotification.cs

+3-2
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
1-
using System.Text.Json.Serialization;
1+
using System.Text.Json.Nodes;
2+
using System.Text.Json.Serialization;
23

34
namespace ModelContextProtocol.Protocol.Messages;
45

@@ -23,5 +24,5 @@ public record JsonRpcNotification : IJsonRpcMessage
2324
/// Optional parameters for the notification.
2425
/// </summary>
2526
[JsonPropertyName("params")]
26-
public object? Params { get; init; }
27+
public JsonNode? Params { get; init; }
2728
}

‎src/ModelContextProtocol/Protocol/Messages/JsonRpcRequest.cs

+3-2
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
1-
using System.Text.Json.Serialization;
1+
using System.Text.Json.Nodes;
2+
using System.Text.Json.Serialization;
23

34
namespace ModelContextProtocol.Protocol.Messages;
45

@@ -29,5 +30,5 @@ public record JsonRpcRequest : IJsonRpcMessageWithId
2930
/// Optional parameters for the method.
3031
/// </summary>
3132
[JsonPropertyName("params")]
32-
public object? Params { get; init; }
33+
public JsonNode? Params { get; init; }
3334
}

‎src/ModelContextProtocol/Protocol/Messages/JsonRpcResponse.cs

+2-2
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-

1+
using System.Text.Json.Nodes;
22
using System.Text.Json.Serialization;
33

44
namespace ModelContextProtocol.Protocol.Messages;
@@ -23,5 +23,5 @@ public record JsonRpcResponse : IJsonRpcMessageWithId
2323
/// The result of the method invocation.
2424
/// </summary>
2525
[JsonPropertyName("result")]
26-
public required object? Result { get; init; }
26+
public required JsonNode? Result { get; init; }
2727
}

‎src/ModelContextProtocol/Protocol/Transport/SseClientSessionTransport.cs

+3-5
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,6 @@ internal sealed class SseClientSessionTransport : TransportBase
2424
private Task? _receiveTask;
2525
private readonly ILogger _logger;
2626
private readonly McpServerConfig _serverConfig;
27-
private readonly JsonSerializerOptions _jsonOptions;
2827
private readonly TaskCompletionSource<bool> _connectionEstablished;
2928

3029
private string EndpointName => $"Client (SSE) for ({_serverConfig.Id}: {_serverConfig.Name})";
@@ -50,7 +49,6 @@ public SseClientSessionTransport(SseClientTransportOptions transportOptions, Mcp
5049
_httpClient = httpClient;
5150
_connectionCts = new CancellationTokenSource();
5251
_logger = (ILogger?)loggerFactory?.CreateLogger<SseClientTransport>() ?? NullLogger.Instance;
53-
_jsonOptions = McpJsonUtilities.DefaultOptions;
5452
_connectionEstablished = new TaskCompletionSource<bool>();
5553
}
5654

@@ -94,7 +92,7 @@ public override async Task SendMessageAsync(
9492
throw new InvalidOperationException("Transport not connected");
9593

9694
using var content = new StringContent(
97-
JsonSerializer.Serialize(message, _jsonOptions.GetTypeInfo<IJsonRpcMessage>()),
95+
JsonSerializer.Serialize(message, McpJsonUtilities.JsonContext.Default.IJsonRpcMessage),
9896
Encoding.UTF8,
9997
"application/json"
10098
);
@@ -127,7 +125,7 @@ public override async Task SendMessageAsync(
127125
}
128126
else
129127
{
130-
JsonRpcResponse initializeResponse = JsonSerializer.Deserialize(responseContent, _jsonOptions.GetTypeInfo<JsonRpcResponse>()) ??
128+
JsonRpcResponse initializeResponse = JsonSerializer.Deserialize(responseContent, McpJsonUtilities.JsonContext.Default.JsonRpcResponse) ??
131129
throw new McpTransportException("Failed to initialize client");
132130

133131
_logger.TransportReceivedMessageParsed(EndpointName, messageId);
@@ -259,7 +257,7 @@ private async Task ProcessSseMessage(string data, CancellationToken cancellation
259257

260258
try
261259
{
262-
var message = JsonSerializer.Deserialize(data, _jsonOptions.GetTypeInfo<IJsonRpcMessage>());
260+
var message = JsonSerializer.Deserialize(data, McpJsonUtilities.JsonContext.Default.IJsonRpcMessage);
263261
if (message == null)
264262
{
265263
_logger.TransportMessageParseUnexpectedType(EndpointName, data);

0 commit comments

Comments
 (0)