feat: Implement per-session prompt functionality

README.md

@@ -547,6 +547,7 @@ MCP-Go provides a robust session management system that allows you to:
 - Register and track client sessions
 - Send notifications to specific clients
 - Provide per-session tool customization
+- Provide per-session prompt customization
 
 <details>
 <summary>Show Session Management Examples</summary>

server/errors.go

@@ -17,6 +17,7 @@ var (
 	ErrSessionExists                = errors.New("session already exists")
 	ErrSessionNotInitialized        = errors.New("session not properly initialized")
 	ErrSessionDoesNotSupportTools   = errors.New("session does not support per-session tools")
+	ErrSessionDoesNotSupportPrompts = errors.New("session does not support per-session prompts")
 	ErrSessionDoesNotSupportLogging = errors.New("session does not support setting logging level")
 
 	// Notification-related errors

server/server.go

@@ -832,6 +832,34 @@ func (s *MCPServer) handleListPrompts(
 	}
 	s.promptsMu.RUnlock()
 
+	// Check if there are session-specific prompts
+	session := ClientSessionFromContext(ctx)
+	if session != nil {
+		if sessionWithPrompts, ok := session.(SessionWithPrompts); ok {
+			if sessionPrompts := sessionWithPrompts.GetSessionPrompts(); sessionPrompts != nil {
+				// Override or add session-specific prompts
+				// We need to create a map first to merge the prompts properly
+				promptMap := make(map[string]mcp.Prompt)
+
+				// Add global prompts first
+				for _, prompt := range prompts {
+					promptMap[prompt.Name] = prompt
+				}
+
+				// Then override with session-specific tools
+				for name, serverPrompt := range sessionPrompts {
+					promptMap[name] = serverPrompt.Prompt
+				}
+
+				// Convert back to slice
+				prompts = make([]mcp.Prompt, 0, len(promptMap))
+				for _, prompt := range promptMap {
+					prompts = append(prompts, prompt)
+				}
+			}
+		}
+	}
+
 	// sort prompts by name
 	sort.Slice(prompts, func(i, j int) bool {
 		return prompts[i].Name < prompts[j].Name
@@ -863,9 +891,28 @@ func (s *MCPServer) handleGetPrompt(
 	id any,
 	request mcp.GetPromptRequest,
 ) (*mcp.GetPromptResult, *requestError) {
-	s.promptsMu.RLock()
-	handler, ok := s.promptHandlers[request.Params.Name]
-	s.promptsMu.RUnlock()
+	// First check session-specific prompts
+	var handler PromptHandlerFunc
+	var ok bool
+
+	session := ClientSessionFromContext(ctx)
+	if session != nil {
+		if sessionWithPrompts, typeAssertOk := session.(SessionWithPrompts); typeAssertOk {
+			if sessionPrompts := sessionWithPrompts.GetSessionPrompts(); sessionPrompts != nil {
+				if serverPrompt, sessionOk := sessionPrompts[request.Params.Name]; sessionOk {
+					handler = serverPrompt.Handler
+					ok = true
+				}
+			}
+		}
+	}
+
+	// If not found in session prompts, check global prompts
+	if !ok {
+		s.promptsMu.RLock()
+		handler, ok = s.promptHandlers[request.Params.Name]
+		s.promptsMu.RUnlock()
+	}
 
 	if !ok {
 		return nil, &requestError{

server/session.go

@@ -39,6 +39,14 @@ type SessionWithTools interface {
 	SetSessionTools(tools map[string]ServerTool)
 }
 
+type SessionWithPrompts interface {
+	ClientSession
+	// GetPrompts returns the prompts specific to this session, if any
+	GetSessionPrompts() map[string]ServerPrompt
+	// SetPrompts sets prompts specific to this session
+	SetSessionPrompts(prompts map[string]ServerPrompt)
+}
+
 // SessionWithClientInfo is an extension of ClientSession that can store client info
 type SessionWithClientInfo interface {
 	ClientSession
@@ -378,3 +386,60 @@ func (s *MCPServer) DeleteSessionTools(sessionID string, names ...string) error
 
 	return nil
 }
+
+func (s *MCPServer) AddSessionPrompts(sessionID string, prompts ...ServerPrompt) error {
+	sessionValue, ok := s.sessions.Load(sessionID)
+	if !ok {
+		return ErrSessionNotFound
+	}
+
+	session, ok := sessionValue.(SessionWithPrompts)
+	if !ok {
+		return ErrSessionDoesNotSupportPrompts
+	}
+
+	s.implicitlyRegisterPromptCapabilities()
+
+	// Get existing prompts (this should return a thread-safe copy)
+	sessionPrompts := session.GetSessionPrompts()
+
+	// Create a new map to avoid concurrent modification issues
+	newSessionPrompts := make(map[string]ServerPrompt, len(sessionPrompts)+len(prompts))
+
+	// Copy existing prompts
+	for k, v := range sessionPrompts {
+		newSessionPrompts[k] = v
+	}
+
+	// Add new prompts
+	for _, prompt := range prompts {
+		newSessionPrompts[prompt.Prompt.Name] = prompt
+	}
+
+	// Set the prompts (this should be thread-safe)
+	session.SetSessionPrompts(newSessionPrompts)
+
+	if session.Initialized() && s.capabilities.prompts != nil && s.capabilities.prompts.listChanged {
+		// Send notification only to this session
+		if err := s.SendNotificationToSpecificClient(sessionID, "notifications/prompts/list_changed", nil); err != nil {
+			// Log the error but don't fail the operation
+			// The prompts were successfully added, but notification failed
+			if s.hooks != nil && len(s.hooks.OnError) > 0 {
+				hooks := s.hooks
+				go func(sID string, hooks *Hooks) {
+					ctx := context.Background()
+					hooks.onError(ctx, nil, "notification", map[string]any{
+						"method":    "notifications/prompts/list_changed",
+						"sessionID": sID,
+					}, fmt.Errorf("failed to send notification after adding prompts: %w", err))
+				}(sessionID, hooks)
+			}
+		}
+	}
+
+	return nil
+}
+
+func (s *MCPServer) AddSessionPrompt(sessionID string, prompt mcp.Prompt, handler PromptHandlerFunc) error {
+	return s.AddSessionPrompts(sessionID, ServerPrompt{Prompt: prompt, Handler: handler})
+}