Move inventory creation to HTTP handler and add factory pattern.

Author: omgitsads

internal/ghmcp/server.go

@@ -98,8 +98,22 @@ func NewStdioMCPServer(cfg github.MCPServerConfig) (*mcp.Server, error) {
 		github.FeatureFlags{LockdownMode: cfg.LockdownMode},
 		cfg.ContentWindowSize,
 	)
+	// Build and register the tool/resource/prompt inventory
+	inventoryBuilder := github.NewInventory(cfg.Translator).
+		WithDeprecatedAliases(github.DeprecatedToolAliases).
+		WithReadOnly(cfg.ReadOnly).
+		WithToolsets(cfg.EnabledToolsets).
+		WithTools(github.CleanTools(cfg.EnabledTools))
+		// WithFeatureChecker(createFeatureChecker(cfg.EnabledFeatures))
+
+	// Apply token scope filtering if scopes are known (for PAT filtering)
+	if cfg.TokenScopes != nil {
+		inventoryBuilder = inventoryBuilder.WithFilter(github.CreateToolScopeFilter(cfg.TokenScopes))
+	}
+
+	inventory := inventoryBuilder.Build()
 
-	ghServer, err := github.NewMCPServer(&cfg, deps)
+	ghServer, err := github.NewMCPServer(&cfg, deps, inventory)
 	if err != nil {
 		return nil, fmt.Errorf("failed to create GitHub MCP server: %w", err)
 	}

pkg/github/server.go

@@ -66,7 +66,7 @@ type MCPServerConfig struct {
 	TokenScopes []string
 }
 
-func NewMCPServer(cfg *MCPServerConfig, deps ToolDependencies) (*mcp.Server, error) {
+func NewMCPServer(cfg *MCPServerConfig, deps ToolDependencies, inventory *inventory.Inventory) (*mcp.Server, error) {
 	enabledToolsets := resolveEnabledToolsets(cfg)
 
 	// For instruction generation, we need actual toolset names (not nil).
@@ -99,21 +99,6 @@ func NewMCPServer(cfg *MCPServerConfig, deps ToolDependencies) (*mcp.Server, err
 	ghServer.AddReceivingMiddleware(addGitHubAPIErrorToContext)
 	ghServer.AddReceivingMiddleware(InjectDepsMiddleware(deps))
 
-	// Build and register the tool/resource/prompt inventory
-	inventoryBuilder := NewInventory(cfg.Translator).
-		WithDeprecatedAliases(DeprecatedToolAliases).
-		WithReadOnly(cfg.ReadOnly).
-		WithToolsets(enabledToolsets).
-		WithTools(CleanTools(cfg.EnabledTools)).
-		WithFeatureChecker(createFeatureChecker(cfg.EnabledFeatures))
-
-	// Apply token scope filtering if scopes are known (for PAT filtering)
-	if cfg.TokenScopes != nil {
-		inventoryBuilder = inventoryBuilder.WithFilter(CreateToolScopeFilter(cfg.TokenScopes))
-	}
-
-	inventory := inventoryBuilder.Build()
-
 	if unrecognized := inventory.UnrecognizedToolsets(); len(unrecognized) > 0 {
 		fmt.Fprintf(os.Stderr, "Warning: unrecognized toolsets ignored: %s\n", strings.Join(unrecognized, ", "))
 	}

pkg/http/handler.go

@@ -3,34 +3,41 @@ package http
 import (
 	"log/slog"
 	"net/http"
+	"strings"
 
 	"github.com/github/github-mcp-server/pkg/github"
 	"github.com/github/github-mcp-server/pkg/http/middleware"
+	"github.com/github/github-mcp-server/pkg/inventory"
 	"github.com/github/github-mcp-server/pkg/lockdown"
 	"github.com/github/github-mcp-server/pkg/translations"
 	"github.com/github/github-mcp-server/pkg/utils"
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 )
 
+type InventoryFactoryFunc func(r *http.Request) *inventory.Inventory
+
 type HttpMcpHandler struct {
-	config         *HTTPServerConfig
-	apiHosts       utils.ApiHost
-	logger         *slog.Logger
-	t              translations.TranslationHelperFunc
-	repoAccessOpts []lockdown.RepoAccessOption
+	config               *HTTPServerConfig
+	apiHosts             utils.ApiHost
+	logger               *slog.Logger
+	t                    translations.TranslationHelperFunc
+	repoAccessOpts       []lockdown.RepoAccessOption
+	inventoryFactoryFunc InventoryFactoryFunc
 }
 
 func NewHttpMcpHandler(cfg *HTTPServerConfig,
 	t translations.TranslationHelperFunc,
 	apiHosts *utils.ApiHost,
 	repoAccessOptions []lockdown.RepoAccessOption,
-	logger *slog.Logger) *HttpMcpHandler {
+	logger *slog.Logger,
+	inventoryFactory InventoryFactoryFunc) *HttpMcpHandler {
 	return &HttpMcpHandler{
-		config:         cfg,
-		apiHosts:       *apiHosts,
-		logger:         logger,
-		t:              t,
-		repoAccessOpts: repoAccessOptions,
+		config:               cfg,
+		apiHosts:             *apiHosts,
+		logger:               logger,
+		t:                    t,
+		repoAccessOpts:       repoAccessOptions,
+		inventoryFactoryFunc: inventoryFactory,
 	}
 }
 
@@ -48,6 +55,8 @@ func (s *HttpMcpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		s.config.ContentWindowSize,
 	)
 
+	inventory := s.inventoryFactoryFunc(r)
+
 	ghServer, err := github.NewMCPServer(&github.MCPServerConfig{
 		Version:           s.config.Version,
 		Host:              s.config.Host,
@@ -60,7 +69,7 @@ func (s *HttpMcpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 		ContentWindowSize: s.config.ContentWindowSize,
 		Logger:            s.logger,
 		RepoAccessTTL:     s.config.RepoAccessCacheTTL,
-	}, deps)
+	}, deps, inventory)
 	if err != nil {
 		w.WriteHeader(http.StatusInternalServerError)
 	}
@@ -73,3 +82,29 @@ func (s *HttpMcpHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 
 	middleware.ExtractUserToken()(mcpHandler).ServeHTTP(w, r)
 }
+
+func DefaultInventoryFactory(cfg *HTTPServerConfig, t translations.TranslationHelperFunc) InventoryFactoryFunc {
+	return func(r *http.Request) *inventory.Inventory {
+		b := github.NewInventory(t).WithDeprecatedAliases(github.DeprecatedToolAliases)
+		b = InventoryFiltersForRequestHeaders(r, b)
+		return b.Build()
+	}
+}
+
+func InventoryFiltersForRequestHeaders(r *http.Request, builder *inventory.Builder) *inventory.Builder {
+	if r.Header.Get("X-MCP-Readonly") != "" {
+		builder = builder.WithReadOnly(true)
+	}
+
+	if toolsetsStr := r.Header.Get("X-MCP-Toolsets"); toolsetsStr != "" {
+		toolsets := strings.Split(toolsetsStr, ",")
+		builder = builder.WithToolsets(toolsets)
+	}
+
+	if toolsStr := r.Header.Get("X-MCP-Tools"); toolsStr != "" {
+		tools := strings.Split(toolsStr, ",")
+		builder = builder.WithTools(github.CleanTools(tools))
+	}
+
+	return builder
+}

pkg/http/server.go

@@ -98,7 +98,7 @@ func RunHTTPServer(cfg HTTPServerConfig) error {
 		repoAccessOpts = append(repoAccessOpts, lockdown.WithTTL(*cfg.RepoAccessCacheTTL))
 	}
 
-	handler := NewHttpMcpHandler(&cfg, t, &apiHost, repoAccessOpts, logger)
+	handler := NewHttpMcpHandler(&cfg, t, &apiHost, repoAccessOpts, logger, DefaultInventoryFactory(&cfg, t))
 
 	r := chi.NewRouter()
 	r.Mount("/", handler)