feat(MCPServer): support logging/setlevel request (#276)

* feat(MCPServer): support logging/setlevel request

* update template file and adopt coderabbitai suggestion

Author: cryo-zd

mcp/types.go

@@ -50,6 +50,10 @@ const (
 	// https://modelcontextprotocol.io/specification/2024-11-05/server/tools/
 	MethodToolsCall MCPMethod = "tools/call"
 
+	// MethodSetLogLevel configures the minimum log level for client
+	// https://modelcontextprotocol.io/specification/2025-03-26/server/utilities/logging
+	MethodSetLogLevel MCPMethod = "logging/setLevel"
+
 	// MethodNotificationResourcesListChanged notifies when the list of available resources changes.
 	// https://modelcontextprotocol.io/specification/2025-03-26/server/resources#list-changed-notification
 	MethodNotificationResourcesListChanged = "notifications/resources/list_changed"

server/errors.go

@@ -13,10 +13,11 @@ var (
 	ErrToolNotFound     = errors.New("tool not found")
 
 	// Session-related errors
-	ErrSessionNotFound            = errors.New("session not found")
-	ErrSessionExists              = errors.New("session already exists")
-	ErrSessionNotInitialized      = errors.New("session not properly initialized")
-	ErrSessionDoesNotSupportTools = errors.New("session does not support per-session tools")
+	ErrSessionNotFound            	= errors.New("session not found")
+	ErrSessionExists              	= errors.New("session already exists")
+	ErrSessionNotInitialized      	= errors.New("session not properly initialized")
+	ErrSessionDoesNotSupportTools 	= errors.New("session does not support per-session tools")
+	ErrSessionDoesNotSupportLogging = errors.New("session does not support setting logging level")
 
 	// Notification-related errors
 	ErrNotificationNotInitialized = errors.New("notification channel not initialized")

server/hooks.go

@@ -27,6 +27,16 @@ var MCPRequestTypes = []MCPRequestType{
 		HookName:       "Ping",
 		UnmarshalError: "invalid ping request",
 		HandlerFunc:    "handlePing",
+	}, {
+		MethodName:     "MethodSetLogLevel",
+		ParamType:      "SetLevelRequest",
+		ResultType:     "EmptyResult",
+		Group:          "logging",
+		GroupName:      "Logging",
+		GroupHookName:  "Logging",
+		HookName:       "SetLevel",
+		UnmarshalError: "invalid set level request",
+		HandlerFunc:    "handleSetLevel",
 	}, {
 		MethodName:     "MethodResourcesList",
 		ParamType:      "ListResourcesRequest",

server/internal/gen/data.go

@@ -161,7 +161,7 @@ type serverCapabilities struct {
 	tools     *toolCapabilities
 	resources *resourceCapabilities
 	prompts   *promptCapabilities
-	logging   bool
+	logging   *bool
 }
 
 // resourceCapabilities defines the supported resource-related features
@@ -260,7 +260,7 @@ func WithToolCapabilities(listChanged bool) ServerOption {
 // WithLogging enables logging capabilities for the server
 func WithLogging() ServerOption {
 	return func(s *MCPServer) {
-		s.capabilities.logging = true
+		s.capabilities.logging = mcp.ToBoolPtr(true)
 	}
 }
 
@@ -289,7 +289,7 @@ func NewMCPServer(
 			tools:     nil,
 			resources: nil,
 			prompts:   nil,
-			logging:   false,
+			logging:   nil,
 		},
 	}
 
@@ -521,7 +521,7 @@ func (s *MCPServer) handleInitialize(
 		}
 	}
 
-	if s.capabilities.logging {
+	if s.capabilities.logging != nil && *s.capabilities.logging {
 		capabilities.Logging = &struct{}{}
 	}
 
@@ -549,6 +549,49 @@ func (s *MCPServer) handlePing(
 	return &mcp.EmptyResult{}, nil
 }
 
+func (s *MCPServer) handleSetLevel(
+	ctx context.Context,
+	id any,
+	request mcp.SetLevelRequest,
+) (*mcp.EmptyResult, *requestError) {
+	clientSession := ClientSessionFromContext(ctx)
+	if clientSession == nil || !clientSession.Initialized() {
+		return nil, &requestError{
+			id:   id,
+			code: mcp.INTERNAL_ERROR,
+			err:  ErrSessionNotInitialized,
+		}
+	}
+
+	sessionLogging, ok := clientSession.(SessionWithLogging)
+	if !ok {
+		return nil, &requestError{
+			id:   id,
+			code: mcp.INTERNAL_ERROR,
+			err:  ErrSessionDoesNotSupportLogging,
+		}
+	}
+
+	level := request.Params.Level
+	// Validate logging level
+	switch level {
+	case mcp.LoggingLevelDebug, mcp.LoggingLevelInfo, mcp.LoggingLevelNotice,
+		mcp.LoggingLevelWarning, mcp.LoggingLevelError, mcp.LoggingLevelCritical,
+		mcp.LoggingLevelAlert, mcp.LoggingLevelEmergency:
+		// Valid level
+	default:
+		return nil, &requestError{
+			id:   id,
+			code: mcp.INVALID_PARAMS,
+			err:  fmt.Errorf("invalid logging level '%s'", level),
+		}
+	}
+	
+	sessionLogging.SetLogLevel(level)
+
+	return &mcp.EmptyResult{}, nil
+}
+
 func listByPagination[T mcp.Named](
 	ctx context.Context,
 	s *MCPServer,

server/request_handler.go

@@ -19,6 +19,15 @@ type ClientSession interface {
 	SessionID() string
 }
 
+// SessionWithLogging is an extension of ClientSession that can receive log message notifications and set log level
+type SessionWithLogging interface {
+	ClientSession
+	// SetLogLevel sets the minimum log level
+	SetLogLevel(level mcp.LoggingLevel)
+	// GetLogLevel retrieves the minimum log level
+	GetLogLevel() mcp.LoggingLevel
+}
+
 // SessionWithTools is an extension of ClientSession that can store session-specific tool data
 type SessionWithTools interface {
 	ClientSession

server/server.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"errors"
 	"sync"
+	"sync/atomic"
 	"testing"
 	"time"
 
@@ -98,9 +99,47 @@ func (f *sessionTestClientWithTools) SetSessionTools(tools map[string]ServerTool
 	f.sessionTools = toolsCopy
 }
 
-// Verify that both implementations satisfy their respective interfaces
-var _ ClientSession = &sessionTestClient{}
-var _ SessionWithTools = &sessionTestClientWithTools{}
+// sessionTestClientWithTools implements the SessionWithLogging interface for testing
+type sessionTestClientWithLogging struct {
+	sessionID           string
+	notificationChannel chan mcp.JSONRPCNotification
+	initialized         bool
+	loggingLevel 		atomic.Value
+}
+
+func (f *sessionTestClientWithLogging) SessionID() string {
+	return f.sessionID
+}
+
+func (f *sessionTestClientWithLogging) NotificationChannel() chan<- mcp.JSONRPCNotification {
+	return f.notificationChannel
+}
+
+func (f *sessionTestClientWithLogging) Initialize() {
+	// set default logging level
+	f.loggingLevel.Store(mcp.LoggingLevelError)
+	f.initialized = true
+}
+
+func (f *sessionTestClientWithLogging) Initialized() bool {
+	return f.initialized
+}
+
+func (f *sessionTestClientWithLogging) SetLogLevel(level mcp.LoggingLevel) {
+	f.loggingLevel.Store(level)
+}
+
+func (f *sessionTestClientWithLogging) GetLogLevel() mcp.LoggingLevel {
+	level := f.loggingLevel.Load()
+	return level.(mcp.LoggingLevel)
+}
+
+// Verify that all implementations satisfy their respective interfaces
+var (
+	_ ClientSession 			= (*sessionTestClient)(nil)
+	_ SessionWithTools 			= (*sessionTestClientWithTools)(nil)
+	_ SessionWithLogging		= (*sessionTestClientWithLogging)(nil)
+)
 
 func TestSessionWithTools_Integration(t *testing.T) {
 	server := NewMCPServer("test-server", "1.0.0", WithToolCapabilities(true))
@@ -917,3 +956,89 @@ func TestMCPServer_ToolNotificationsDisabled(t *testing.T) {
 	// Verify tool was deleted from session
 	assert.Len(t, session.GetSessionTools(), 0)
 }
+
+func TestMCPServer_SetLevelNotEnabled(t *testing.T) {
+	// Create server without logging capability
+	server := NewMCPServer("test-server", "1.0.0")
+
+	// Create and initialize a session
+	sessionChan := make(chan mcp.JSONRPCNotification, 10)
+	session := &sessionTestClientWithLogging{
+		sessionID:           "session-1",
+		notificationChannel: sessionChan,
+	}
+	session.Initialize()
+
+	// Register the session
+	err := server.RegisterSession(context.Background(), session)
+	require.NoError(t, err)
+
+	// Try to set logging level when capability is disabled
+	sessionCtx := server.WithContext(context.Background(), session)
+	setRequest := map[string]any{
+		"jsonrpc": "2.0",
+		"id":      1,
+		"method":  "logging/setLevel",
+		"params": map[string]any{
+			"level": mcp.LoggingLevelCritical,
+		},
+	}
+	requestBytes, err := json.Marshal(setRequest)
+	require.NoError(t, err)
+
+	response := server.HandleMessage(sessionCtx, requestBytes)
+	errorResponse, ok := response.(mcp.JSONRPCError)
+	assert.True(t, ok)
+
+	// Verify we get a METHOD_NOT_FOUND error
+	assert.NotNil(t, errorResponse.Error)
+	assert.Equal(t, mcp.METHOD_NOT_FOUND, errorResponse.Error.Code)
+}
+
+func TestMCPServer_SetLevel(t *testing.T) {
+	server := NewMCPServer("test-server", "1.0.0", WithLogging())
+
+	// Create and initicalize a session
+	sessionChan := make(chan mcp.JSONRPCNotification, 10)
+	session := &sessionTestClientWithLogging{
+		sessionID:           "session-1",
+		notificationChannel: sessionChan,
+	}
+	session.Initialize()
+
+	// Check default logging level
+	if session.GetLogLevel() != mcp.LoggingLevelError {
+		t.Errorf("Expected error level, got %v", session.GetLogLevel())
+	}
+
+	// Register the session
+	err := server.RegisterSession(context.Background(), session)
+	require.NoError(t, err)
+
+	// Set Logging level to critical
+	sessionCtx := server.WithContext(context.Background(), session)
+	setRequest := map[string]any{
+		"jsonrpc": "2.0",
+		"id":      1,
+		"method":  "logging/setLevel",
+		"params": map[string]any{
+			"level": mcp.LoggingLevelCritical,
+		},
+	}
+	requestBytes, err := json.Marshal(setRequest)
+	if err != nil {
+		t.Fatalf("Failed to marshal tool request: %v", err)
+	}
+
+	response := server.HandleMessage(sessionCtx, requestBytes)
+	resp, ok := response.(mcp.JSONRPCResponse)
+	assert.True(t, ok)
+
+	_, ok = resp.Result.(mcp.EmptyResult)
+	assert.True(t, ok)
+
+	// Check logging level
+	if session.GetLogLevel() != mcp.LoggingLevelCritical {
+		t.Errorf("Expected critical level, got %v", session.GetLogLevel())
+	}
+}