feat(inventory): add ToolHandlerMiddleware for handler wrapping

Add middleware support to tool registration, allowing callers to wrap
handlers with cross-cutting concerns like observability, error tracking,
or request/response modification.

New APIs:
- ToolHandlerMiddleware type for wrapping handlers with tool name context
- RegisterFuncWithMiddleware on ServerTool for single tool registration
- RegisterToolsWithMiddleware on Inventory for bulk tool registration
- RegisterAllWithMiddleware on Inventory for full registration with middleware

This restores the ability for the remote server to wrap handlers that was
lost during the inventory refactor. The remote server needs this to check
result.IsError and context errors for Datadog significance tracking.

Existing RegisterFunc/RegisterTools/RegisterAll APIs unchanged (call
WithMiddleware variants with nil).

Author: SamMorrowDrums

pkg/inventory/registry.go

@@ -171,8 +171,16 @@ func (r *Inventory) ToolsetDescriptions() map[ToolsetID]string {
 // RegisterTools registers all available tools with the server using the provided dependencies.
 // The context is used for feature flag evaluation.
 func (r *Inventory) RegisterTools(ctx context.Context, s *mcp.Server, deps any) {
+	r.RegisterToolsWithMiddleware(ctx, s, deps, nil)
+}
+
+// RegisterToolsWithMiddleware registers all available tools with the server using the provided dependencies.
+// If middleware is provided, it wraps each handler before registration.
+// This allows callers to add observability, error tracking, or other cross-cutting concerns.
+// The context is used for feature flag evaluation.
+func (r *Inventory) RegisterToolsWithMiddleware(ctx context.Context, s *mcp.Server, deps any, middleware ToolHandlerMiddleware) {
 	for _, tool := range r.AvailableTools(ctx) {
-		tool.RegisterFunc(s, deps)
+		tool.RegisterFuncWithMiddleware(s, deps, middleware)
 	}
 }
 
@@ -195,7 +203,15 @@ func (r *Inventory) RegisterPrompts(ctx context.Context, s *mcp.Server) {
 // RegisterAll registers all available tools, resources, and prompts with the server.
 // The context is used for feature flag evaluation.
 func (r *Inventory) RegisterAll(ctx context.Context, s *mcp.Server, deps any) {
-	r.RegisterTools(ctx, s, deps)
+	r.RegisterAllWithMiddleware(ctx, s, deps, nil)
+}
+
+// RegisterAllWithMiddleware registers all available tools, resources, and prompts with the server.
+// If middleware is provided, it wraps each tool handler before registration.
+// This allows callers to add observability, error tracking, or other cross-cutting concerns.
+// The context is used for feature flag evaluation.
+func (r *Inventory) RegisterAllWithMiddleware(ctx context.Context, s *mcp.Server, deps any, middleware ToolHandlerMiddleware) {
+	r.RegisterToolsWithMiddleware(ctx, s, deps, middleware)
 	r.RegisterResourceTemplates(ctx, s, deps)
 	r.RegisterPrompts(ctx, s)
 }

pkg/inventory/server_tool.go

@@ -14,6 +14,12 @@ import (
 // should define their own typed dependencies struct and type-assert as needed.
 type HandlerFunc func(deps any) mcp.ToolHandler
 
+// ToolHandlerMiddleware wraps a tool handler to add cross-cutting concerns like
+// observability, error tracking, or request/response modification.
+// The middleware receives the tool name for context (e.g., logging, metrics).
+// Return the wrapped handler that should be registered with the server.
+type ToolHandlerMiddleware func(toolName string, handler mcp.ToolHandler) mcp.ToolHandler
+
 // ToolsetID is a unique identifier for a toolset.
 // Using a distinct type provides compile-time type safety.
 type ToolsetID string
@@ -83,7 +89,18 @@ func (st *ServerTool) Handler(deps any) mcp.ToolHandler {
 // RegisterFunc registers the tool with the server using the provided dependencies.
 // Panics if the tool has no handler - all tools should have handlers.
 func (st *ServerTool) RegisterFunc(s *mcp.Server, deps any) {
+	st.RegisterFuncWithMiddleware(s, deps, nil)
+}
+
+// RegisterFuncWithMiddleware registers the tool with the server using the provided dependencies.
+// If middleware is provided, it wraps the handler before registration.
+// This allows callers to add observability, error tracking, or other cross-cutting concerns.
+// Panics if the tool has no handler - all tools should have handlers.
+func (st *ServerTool) RegisterFuncWithMiddleware(s *mcp.Server, deps any, middleware ToolHandlerMiddleware) {
 	handler := st.Handler(deps) // This will panic if HandlerFunc is nil
+	if middleware != nil {
+		handler = middleware(st.Tool.Name, handler)
+	}
 	s.AddTool(&st.Tool, handler)
 }