Fix missing renames

Author: MackinnonBuck

src/ModelContextProtocol.Core/McpSession.cs

@@ -65,7 +65,7 @@ public abstract class McpSession : IAsyncDisposable
     /// <para>
     /// This method provides low-level access to send any JSON-RPC message. For specific message types,
     /// consider using the higher-level methods such as <see cref="SendRequestAsync"/> or extension methods
-    /// like <see cref="McpEndpointExtensions.SendNotificationAsync(McpSession, string, CancellationToken)"/>,
+    /// like <see cref="McpSessionExtensions.SendNotificationAsync(McpSession, string, CancellationToken)"/>,
     /// which provide a simpler API.
     /// </para>
     /// <para>

src/ModelContextProtocol.Core/McpEndpointExtensions.cs renamed to src/ModelContextProtocol.Core/McpSessionExtensions.cs

@@ -12,30 +12,30 @@ namespace ModelContextProtocol;
 /// </summary>
 /// <remarks>
 /// <para>
-/// This class provides strongly-typed methods for working with the Model Context Protocol (MCP) endpoints,
+/// This class provides strongly-typed methods for working with the Model Context Protocol (MCP) sessions,
 /// simplifying JSON-RPC communication by handling serialization and deserialization of parameters and results.
 /// </para>
 /// <para>
 /// These extension methods are designed to be used with both client (<see cref="McpClient"/>) and
 /// server (<see cref="McpServerImpl"/>) implementations of the <see cref="McpSession"/> interface.
 /// </para>
 /// </remarks>
-public static class McpEndpointExtensions
+public static class McpSessionExtensions
 {
     /// <summary>
     /// Sends a JSON-RPC request and attempts to deserialize the result to <typeparamref name="TResult"/>.
     /// </summary>
     /// <typeparam name="TParameters">The type of the request parameters to serialize from.</typeparam>
     /// <typeparam name="TResult">The type of the result to deserialize to.</typeparam>
-    /// <param name="endpoint">The MCP client or server instance.</param>
+    /// <param name="session">The MCP client or server instance.</param>
     /// <param name="method">The JSON-RPC method name to invoke.</param>
     /// <param name="parameters">Object representing the request parameters.</param>
     /// <param name="requestId">The request id for the request.</param>
     /// <param name="serializerOptions">The options governing request serialization.</param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>A task that represents the asynchronous operation. The task result contains the deserialized result.</returns>
     public static ValueTask<TResult> SendRequestAsync<TParameters, TResult>(
-        this McpSession endpoint,
+        this McpSession session,
         string method,
         TParameters parameters,
         JsonSerializerOptions? serializerOptions = null,
@@ -48,15 +48,15 @@ public static ValueTask<TResult> SendRequestAsync<TParameters, TResult>(
 
         JsonTypeInfo<TParameters> paramsTypeInfo = serializerOptions.GetTypeInfo<TParameters>();
         JsonTypeInfo<TResult> resultTypeInfo = serializerOptions.GetTypeInfo<TResult>();
-        return SendRequestAsync(endpoint, method, parameters, paramsTypeInfo, resultTypeInfo, requestId, cancellationToken);
+        return SendRequestAsync(session, method, parameters, paramsTypeInfo, resultTypeInfo, requestId, cancellationToken);
     }
 
     /// <summary>
     /// Sends a JSON-RPC request and attempts to deserialize the result to <typeparamref name="TResult"/>.
     /// </summary>
     /// <typeparam name="TParameters">The type of the request parameters to serialize from.</typeparam>
     /// <typeparam name="TResult">The type of the result to deserialize to.</typeparam>
-    /// <param name="endpoint">The MCP client or server instance.</param>
+    /// <param name="session">The MCP client or server instance.</param>
     /// <param name="method">The JSON-RPC method name to invoke.</param>
     /// <param name="parameters">Object representing the request parameters.</param>
     /// <param name="parametersTypeInfo">The type information for request parameter serialization.</param>
@@ -65,7 +65,7 @@ public static ValueTask<TResult> SendRequestAsync<TParameters, TResult>(
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>A task that represents the asynchronous operation. The task result contains the deserialized result.</returns>
     internal static async ValueTask<TResult> SendRequestAsync<TParameters, TResult>(
-        this McpSession endpoint,
+        this McpSession session,
         string method,
         TParameters parameters,
         JsonTypeInfo<TParameters> parametersTypeInfo,
@@ -74,7 +74,7 @@ internal static async ValueTask<TResult> SendRequestAsync<TParameters, TResult>(
         CancellationToken cancellationToken = default)
         where TResult : notnull
     {
-        Throw.IfNull(endpoint);
+        Throw.IfNull(session);
         Throw.IfNullOrWhiteSpace(method);
         Throw.IfNull(parametersTypeInfo);
         Throw.IfNull(resultTypeInfo);
@@ -86,12 +86,12 @@ internal static async ValueTask<TResult> SendRequestAsync<TParameters, TResult>(
             Params = JsonSerializer.SerializeToNode(parameters, parametersTypeInfo),
         };
 
-        JsonRpcResponse response = await endpoint.SendRequestAsync(jsonRpcRequest, cancellationToken).ConfigureAwait(false);
+        JsonRpcResponse response = await session.SendRequestAsync(jsonRpcRequest, cancellationToken).ConfigureAwait(false);
         return JsonSerializer.Deserialize(response.Result, resultTypeInfo) ?? throw new JsonException("Unexpected JSON result in response.");
     }
 
     /// <summary>
-    /// Sends a parameterless notification to the connected endpoint.
+    /// Sends a parameterless notification to the connected session.
     /// </summary>
     /// <param name="client">The MCP client or server instance.</param>
     /// <param name="method">The notification method name.</param>
@@ -112,18 +112,18 @@ public static Task SendNotificationAsync(this McpSession client, string method,
     }
 
     /// <summary>
-    /// Sends a notification with parameters to the connected endpoint.
+    /// Sends a notification with parameters to the connected session.
     /// </summary>
     /// <typeparam name="TParameters">The type of the notification parameters to serialize.</typeparam>
-    /// <param name="endpoint">The MCP client or server instance.</param>
+    /// <param name="session">The MCP client or server instance.</param>
     /// <param name="method">The JSON-RPC method name for the notification.</param>
     /// <param name="parameters">Object representing the notification parameters.</param>
     /// <param name="serializerOptions">The options governing parameter serialization. If null, default options are used.</param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>A task that represents the asynchronous send operation.</returns>
     /// <remarks>
     /// <para>
-    /// This method sends a notification with parameters to the connected endpoint. Notifications are one-way 
+    /// This method sends a notification with parameters to the connected session. Notifications are one-way 
     /// messages that don't expect a response, commonly used for events, status updates, or signaling changes.
     /// </para>
     /// <para>
@@ -136,7 +136,7 @@ public static Task SendNotificationAsync(this McpSession client, string method,
     /// </para>
     /// </remarks>
     public static Task SendNotificationAsync<TParameters>(
-        this McpSession endpoint,
+        this McpSession session,
         string method,
         TParameters parameters,
         JsonSerializerOptions? serializerOptions = null,
@@ -146,44 +146,44 @@ public static Task SendNotificationAsync<TParameters>(
         serializerOptions.MakeReadOnly();
 
         JsonTypeInfo<TParameters> parametersTypeInfo = serializerOptions.GetTypeInfo<TParameters>();
-        return SendNotificationAsync(endpoint, method, parameters, parametersTypeInfo, cancellationToken);
+        return SendNotificationAsync(session, method, parameters, parametersTypeInfo, cancellationToken);
     }
 
     /// <summary>
     /// Sends a notification to the server with parameters.
     /// </summary>
-    /// <param name="endpoint">The MCP client or server instance.</param>
+    /// <param name="session">The MCP client or server instance.</param>
     /// <param name="method">The JSON-RPC method name to invoke.</param>
     /// <param name="parameters">Object representing the request parameters.</param>
     /// <param name="parametersTypeInfo">The type information for request parameter serialization.</param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     internal static Task SendNotificationAsync<TParameters>(
-        this McpSession endpoint,
+        this McpSession session,
         string method,
         TParameters parameters,
         JsonTypeInfo<TParameters> parametersTypeInfo,
         CancellationToken cancellationToken = default)
     {
-        Throw.IfNull(endpoint);
+        Throw.IfNull(session);
         Throw.IfNullOrWhiteSpace(method);
         Throw.IfNull(parametersTypeInfo);
 
         JsonNode? parametersJson = JsonSerializer.SerializeToNode(parameters, parametersTypeInfo);
-        return endpoint.SendMessageAsync(new JsonRpcNotification { Method = method, Params = parametersJson }, cancellationToken);
+        return session.SendMessageAsync(new JsonRpcNotification { Method = method, Params = parametersJson }, cancellationToken);
     }
 
     /// <summary>
-    /// Notifies the connected endpoint of progress for a long-running operation.
+    /// Notifies the connected session of progress for a long-running operation.
     /// </summary>
-    /// <param name="endpoint">The endpoint issuing the notification.</param>
+    /// <param name="session">The session issuing the notification.</param>
     /// <param name="progressToken">The <see cref="ProgressToken"/> identifying the operation for which progress is being reported.</param>
     /// <param name="progress">The progress update to send, containing information such as percentage complete or status message.</param>
     /// <param name="cancellationToken">The <see cref="CancellationToken"/> to monitor for cancellation requests. The default is <see cref="CancellationToken.None"/>.</param>
     /// <returns>A task representing the completion of the notification operation (not the operation being tracked).</returns>
-    /// <exception cref="ArgumentNullException"><paramref name="endpoint"/> is <see langword="null"/>.</exception>
+    /// <exception cref="ArgumentNullException"><paramref name="session"/> is <see langword="null"/>.</exception>
     /// <remarks>
     /// <para>
-    /// This method sends a progress notification to the connected endpoint using the Model Context Protocol's
+    /// This method sends a progress notification to the connected session using the Model Context Protocol's
     /// standardized progress notification format. Progress updates are identified by a <see cref="ProgressToken"/>
     /// that allows the recipient to correlate multiple updates with a specific long-running operation.
     /// </para>
@@ -192,14 +192,14 @@ internal static Task SendNotificationAsync<TParameters>(
     /// </para>
     /// </remarks>
     public static Task NotifyProgressAsync(
-        this McpSession endpoint,
+        this McpSession session,
         ProgressToken progressToken,
         ProgressNotificationValue progress, 
         CancellationToken cancellationToken = default)
     {
-        Throw.IfNull(endpoint);
+        Throw.IfNull(session);
 
-        return endpoint.SendNotificationAsync(
+        return session.SendNotificationAsync(
             NotificationMethods.ProgressNotification,
             new ProgressNotificationParams
             {

src/ModelContextProtocol.Core/Protocol/ITransport.cs

@@ -63,7 +63,7 @@ public interface ITransport : IAsyncDisposable
     /// <para>
     /// This is a core method used by higher-level abstractions in the MCP protocol implementation.
     /// Most client code should use the higher-level methods provided by <see cref="McpSession"/>,
-    /// <see cref="McpEndpointExtensions"/>, <see cref="McpClientExtensions"/>, or <see cref="McpServerExtensions"/>,
+    /// <see cref="McpSessionExtensions"/>, <see cref="McpClientExtensions"/>, or <see cref="McpServerExtensions"/>,
     /// rather than accessing this method directly.
     /// </para>
     /// </remarks>

src/ModelContextProtocol.Core/Server/DestinationBoundMcpServerSession.cs renamed to src/ModelContextProtocol.Core/Server/DestinationBoundMcpServer.cs

@@ -3,7 +3,7 @@
 
 namespace ModelContextProtocol.Server;
 
-internal sealed class DestinationBoundMcpServerSession(McpServerImpl server, ITransport? transport) : McpServer
+internal sealed class DestinationBoundMcpServer(McpServerImpl server, ITransport? transport) : McpServer
 {
     public override string? SessionId => transport?.SessionId ?? server.SessionId;
     public override ClientCapabilities? ClientCapabilities => server.ClientCapabilities;

src/ModelContextProtocol.Core/Server/McpServerImpl.cs

@@ -561,7 +561,7 @@ private ValueTask<TResult> InvokeHandlerAsync<TParams, TResult>(
     {
         return _servicesScopePerRequest ?
             InvokeScopedAsync(handler, args, cancellationToken) :
-            handler(new(new DestinationBoundMcpServerSession(this, destinationTransport)) { Params = args }, cancellationToken);
+            handler(new(new DestinationBoundMcpServer(this, destinationTransport)) { Params = args }, cancellationToken);
 
         async ValueTask<TResult> InvokeScopedAsync(
             Func<RequestContext<TParams>, CancellationToken, ValueTask<TResult>> handler,
@@ -572,7 +572,7 @@ async ValueTask<TResult> InvokeScopedAsync(
             try
             {
                 return await handler(
-                    new RequestContext<TParams>(new DestinationBoundMcpServerSession(this, destinationTransport))
+                    new RequestContext<TParams>(new DestinationBoundMcpServer(this, destinationTransport))
                     {
                         Services = scope?.ServiceProvider ?? Services,
                         Params = args