Rename AfterAny --> OnSuccess to clarify convention

Author: tylergannon

examples/everything/main.go

@@ -35,8 +35,8 @@ func NewMCPServer() *server.MCPServer {
 	hooks.AddBeforeAny(func(id any, method mcp.MCPMethod, message any) {
 		fmt.Printf("beforeAny: %s, %v, %v\n", method, id, message)
 	})
-	hooks.AddAfterAny(func(id any, method mcp.MCPMethod, message any, result any) {
-		fmt.Printf("afterAny: %s, %v, %v, %v\n", method, id, message, result)
+	hooks.AddOnSuccess(func(id any, method mcp.MCPMethod, message any, result any) {
+		fmt.Printf("onSuccess: %s, %v, %v, %v\n", method, id, message, result)
 	})
 	hooks.AddOnError(func(id any, method mcp.MCPMethod, message any, err error) {
 		fmt.Printf("onError: %s, %v, %v, %v\n", method, id, message, err)

server/hooks.go

@@ -11,13 +11,13 @@ import (
 	"github.com/mark3labs/mcp-go/mcp"
 )
 
-// OnBeforeAnyHookFunc is a function that is called after the request is
+// BeforeAnyHookFunc is a function that is called after the request is
 // parsed but before the method is called.
-type OnBeforeAnyHookFunc func(id any, method mcp.MCPMethod, message any)
+type BeforeAnyHookFunc func(id any, method mcp.MCPMethod, message any)
 
-// OnAfterAnyHookFunc is a hook that will be called after the request
+// OnSuccessHookFunc is a hook that will be called after the request
 // successfully generates a result, but before the result is sent to the client.
-type OnAfterAnyHookFunc func(id any, method mcp.MCPMethod, message any, result any)
+type OnSuccessHookFunc func(id any, method mcp.MCPMethod, message any, result any)
 
 // OnErrorHookFunc is a hook that will be called when an error occurs,
 // either during the request parsing or the method execution.
@@ -59,21 +59,21 @@ type OnAfter{{.HookName}}Func func(id any, message *mcp.{{.ParamType}}, result *
 {{end}}
 
 type Hooks struct {
-	OnBeforeAny      []OnBeforeAnyHookFunc
-	OnAfterAny       []OnAfterAnyHookFunc
+	OnBeforeAny      []BeforeAnyHookFunc
+	OnSuccess        []OnSuccessHookFunc
 	OnError          []OnErrorHookFunc
 {{- range .}}
 	OnBefore{{.HookName}} []OnBefore{{.HookName}}Func
 	OnAfter{{.HookName}}  []OnAfter{{.HookName}}Func
 {{- end}}
 }
 
-func (c *Hooks) AddBeforeAny(hook OnBeforeAnyHookFunc) {
+func (c *Hooks) AddBeforeAny(hook BeforeAnyHookFunc) {
 	c.OnBeforeAny = append(c.OnBeforeAny, hook)
 }
 
-func (c *Hooks) AddAfterAny(hook OnAfterAnyHookFunc) {
-	c.OnAfterAny = append(c.OnAfterAny, hook)
+func (c *Hooks) AddOnSuccess(hook OnSuccessHookFunc) {
+	c.OnSuccess = append(c.OnSuccess, hook)
 }
 
 // AddOnError registers a hook function that will be called when an error occurs.
@@ -133,11 +133,11 @@ func (c *Hooks) beforeAny(id any, method mcp.MCPMethod, message any) {
 	}
 }
 
-func (c *Hooks) afterAny(id any, method mcp.MCPMethod, message any, result any) {
+func (c *Hooks) onSuccess(id any, method mcp.MCPMethod, message any, result any) {
 	if c == nil {
 		return
 	}
-	for _, hook := range c.OnAfterAny {
+	for _, hook := range c.OnSuccess {
 		hook(id, method, message, result)
 	}
 }
@@ -157,7 +157,6 @@ func (c *Hooks) afterAny(id any, method mcp.MCPMethod, message any, result any)
 // - ErrPromptNotFound: When a prompt is not found
 // - ErrToolNotFound: When a tool is not found
 func (c *Hooks) onError(id any, method mcp.MCPMethod, message any, err error) {
-	c.afterAny(id, method, message, err)
 	if c == nil {
 		return
 	}
@@ -186,7 +185,7 @@ func (c *Hooks) before{{.HookName}}(id any, message *mcp.{{.ParamType}}) {
 }
 
 func (c *Hooks) after{{.HookName}}(id any, message *mcp.{{.ParamType}}, result *mcp.{{.ResultType}}) {
-	c.afterAny(id, mcp.{{.MethodName}}, message, result)
+	c.onSuccess(id, mcp.{{.MethodName}}, message, result)
 	if c == nil {
 		return
 	}

server/internal/gen/hooks.go.tmpl

@@ -646,8 +646,6 @@ func (s *MCPServer) handleGetPrompt(
 	handler, ok := s.promptHandlers[request.Params.Name]
 	s.mu.RUnlock()
 
-	fmt.Println("request.Params.Name", request.Params.Name)
-
 	if !ok {
 		return nil, &requestError{
 			id:   id,

server/server.go

@@ -750,7 +750,7 @@ func TestMCPServer_HandleUndefinedHandlers(t *testing.T) {
 	hooks.AddBeforeAny(func(id any, method mcp.MCPMethod, message any) {
 		beforeResults = append(beforeResults, beforeResult{method, message})
 	})
-	hooks.AddAfterAny(func(id any, method mcp.MCPMethod, message any, result any) {
+	hooks.AddOnSuccess(func(id any, method mcp.MCPMethod, message any, result any) {
 		afterResults = append(afterResults, afterResult{method, message, result})
 	})
 
@@ -777,7 +777,7 @@ func TestMCPServer_HandleUndefinedHandlers(t *testing.T) {
 		name              string
 		message           string
 		expectedErr       int
-		validateCallbacks func(t *testing.T, err error, beforeResults beforeResult, afterResults afterResult)
+		validateCallbacks func(t *testing.T, err error, beforeResults beforeResult)
 	}{
 		{
 			name: "Undefined tool",
@@ -791,12 +791,8 @@ func TestMCPServer_HandleUndefinedHandlers(t *testing.T) {
                     }
                 }`,
 			expectedErr: mcp.INVALID_PARAMS,
-			validateCallbacks: func(t *testing.T, err error, beforeResults beforeResult, afterResults afterResult) {
+			validateCallbacks: func(t *testing.T, err error, beforeResults beforeResult) {
 				assert.Equal(t, mcp.MethodToolsCall, beforeResults.method)
-				assert.Equal(t, mcp.MethodToolsCall, afterResults.method)
-				afterResultErr, ok := afterResults.result.(error)
-				assert.True(t, ok)
-				assert.Same(t, err, afterResultErr)
 				assert.True(t, errors.Is(err, ErrToolNotFound))
 			},
 		},
@@ -812,12 +808,8 @@ func TestMCPServer_HandleUndefinedHandlers(t *testing.T) {
                     }
                 }`,
 			expectedErr: mcp.INVALID_PARAMS,
-			validateCallbacks: func(t *testing.T, err error, beforeResults beforeResult, afterResults afterResult) {
+			validateCallbacks: func(t *testing.T, err error, beforeResults beforeResult) {
 				assert.Equal(t, mcp.MethodPromptsGet, beforeResults.method)
-				assert.Equal(t, mcp.MethodPromptsGet, afterResults.method)
-				afterResultErr, ok := afterResults.result.(error)
-				assert.True(t, ok)
-				assert.Same(t, err, afterResultErr)
 				assert.True(t, errors.Is(err, ErrPromptNotFound))
 			},
 		},
@@ -832,12 +824,8 @@ func TestMCPServer_HandleUndefinedHandlers(t *testing.T) {
                     }
                 }`,
 			expectedErr: mcp.INVALID_PARAMS,
-			validateCallbacks: func(t *testing.T, err error, beforeResults beforeResult, afterResults afterResult) {
+			validateCallbacks: func(t *testing.T, err error, beforeResults beforeResult) {
 				assert.Equal(t, mcp.MethodResourcesRead, beforeResults.method)
-				assert.Equal(t, mcp.MethodResourcesRead, afterResults.method)
-				afterResultErr, ok := afterResults.result.(error)
-				assert.True(t, ok)
-				assert.Same(t, err, afterResultErr)
 				assert.True(t, errors.Is(err, ErrResourceNotFound))
 			},
 		},
@@ -847,7 +835,6 @@ func TestMCPServer_HandleUndefinedHandlers(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			errs = nil // Reset errors for each test case
 			beforeResults = nil
-			afterResults = nil
 			response := server.HandleMessage(
 				context.Background(),
 				[]byte(tt.message),
@@ -861,8 +848,8 @@ func TestMCPServer_HandleUndefinedHandlers(t *testing.T) {
 			if tt.validateCallbacks != nil {
 				require.Len(t, errs, 1, "Expected exactly one error")
 				require.Len(t, beforeResults, 1, "Expected exactly one before result")
-				require.Len(t, afterResults, 1, "Expected exactly one after result")
-				tt.validateCallbacks(t, errs[0], beforeResults[0], afterResults[0])
+				require.Len(t, afterResults, 0, "Expected no after results because these calls generate errors")
+				tt.validateCallbacks(t, errs[0], beforeResults[0])
 			}
 		})
 	}
@@ -1165,7 +1152,7 @@ func TestMCPServer_WithHooks(t *testing.T) {
 	// Create hook counters to verify calls
 	var (
 		beforeAnyCount   int
-		afterAnyCount    int
+		onSuccessCount   int
 		onErrorCount     int
 		beforePingCount  int
 		afterPingCount   int
@@ -1175,7 +1162,7 @@ func TestMCPServer_WithHooks(t *testing.T) {
 
 	// Collectors for message and result types
 	var beforeAnyMessages []any
-	var afterAnyData []struct {
+	var onSuccessData []struct {
 		msg any
 		res any
 	}
@@ -1197,11 +1184,11 @@ func TestMCPServer_WithHooks(t *testing.T) {
 		}
 	})
 
-	hooks.AddAfterAny(func(id any, method mcp.MCPMethod, message any, result any) {
-		afterAnyCount++
+	hooks.AddOnSuccess(func(id any, method mcp.MCPMethod, message any, result any) {
+		onSuccessCount++
 		// Only collect ping responses for our test
 		if method == mcp.MethodPing {
-			afterAnyData = append(afterAnyData, struct {
+			onSuccessData = append(onSuccessData, struct {
 				msg any
 				res any
 			}{message, result})
@@ -1301,8 +1288,8 @@ func TestMCPServer_WithHooks(t *testing.T) {
 	// General hooks should be called for all methods
 	// beforeAny is called for all 4 methods (initialize, ping, tools/list, tools/call)
 	assert.Equal(t, 4, beforeAnyCount, "beforeAny should be called for each method")
-	// afterAny is called for all 3 success methods (initialize, ping, tools/list) plus 1 error (tools/call)
-	assert.Equal(t, 4, afterAnyCount, "afterAny should be called for all methods including errors")
+	// onSuccess is called for all 3 success methods (initialize, ping, tools/list)
+	assert.Equal(t, 3, onSuccessCount, "onSuccess should be called after all successful invocations")
 
 	// Error hook should be called once for the failed tools/call
 	assert.Equal(t, 1, onErrorCount, "onError should be called once")
@@ -1312,9 +1299,9 @@ func TestMCPServer_WithHooks(t *testing.T) {
 	require.Len(t, beforeAnyMessages, 1, "Expected one BeforeAny Ping message")
 	assert.IsType(t, beforePingMessages[0], beforeAnyMessages[0], "BeforeAny message should be same type as BeforePing message")
 
-	// Verify type matching between AfterAny and AfterPing
+	// Verify type matching between OnSuccess and AfterPing
 	require.Len(t, afterPingData, 1, "Expected one AfterPing message/result pair")
-	require.Len(t, afterAnyData, 1, "Expected one AfterAny Ping message/result pair")
-	assert.IsType(t, afterPingData[0].msg, afterAnyData[0].msg, "AfterAny message should be same type as AfterPing message")
-	assert.IsType(t, afterPingData[0].res, afterAnyData[0].res, "AfterAny result should be same type as AfterPing result")
+	require.Len(t, onSuccessData, 1, "Expected one OnSuccess Ping message/result pair")
+	assert.IsType(t, afterPingData[0].msg, onSuccessData[0].msg, "OnSuccess message should be same type as AfterPing message")
+	assert.IsType(t, afterPingData[0].res, onSuccessData[0].res, "OnSuccess result should be same type as AfterPing result")
 }