feat(inventory): project owner/repo to Mcp-Param-* headers (SEP-2243)

Annotates owner/repo tool params with x-mcp-header so the SDK projects them
to Mcp-Param-owner/Mcp-Param-repo request headers. A remote proxy can route
and filter on owner/repo from headers instead of re-parsing the JSON-RPC body
(headers are SDK-validated against the body). No-op for tools without these
params; old-protocol traffic unaffected.

Refs: github/copilot-mcp-core#1709, #1828

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: Copilot

pkg/inventory/server_tool.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 
 	"github.com/github/github-mcp-server/pkg/octicons"
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 )
 
@@ -116,9 +117,38 @@ func (st *ServerTool) RegisterFunc(s *mcp.Server, deps any) {
 	if len(toolCopy.Icons) == 0 {
 		toolCopy.Icons = st.Toolset.Icons()
 	}
+	// Project routing-relevant params to standard MCP-Param-* headers (SEP-2243)
+	// so a remote proxy can read owner/repo from headers instead of re-parsing the
+	// JSON-RPC body. No-op for tools without these params.
+	annotateHeaderParams(&toolCopy)
 	s.AddTool(&toolCopy, handler)
 }
 
+// headerParams maps tool input properties to the MCP-Param-* header name a
+// header-aware proxy reads, avoiding a second parse of the request body.
+var headerParams = map[string]string{"owner": "owner", "repo": "repo"}
+
+// annotateHeaderParams adds an "x-mcp-header" annotation to matching top-level
+// input properties, which the SDK projects onto Mcp-Param-{name} request headers.
+func annotateHeaderParams(tool *mcp.Tool) {
+	schema, ok := tool.InputSchema.(*jsonschema.Schema)
+	if !ok || schema == nil {
+		return
+	}
+	for prop, header := range headerParams {
+		ps := schema.Properties[prop]
+		if ps == nil {
+			continue
+		}
+		if ps.Extra == nil {
+			ps.Extra = map[string]any{}
+		}
+		if _, exists := ps.Extra["x-mcp-header"]; !exists {
+			ps.Extra["x-mcp-header"] = header
+		}
+	}
+}
+
 // NewServerToolWithContextHandler creates a ServerTool with a handler that receives deps via context.
 // This is the preferred approach for tools because it doesn't create closures at registration time,
 // which is critical for performance in servers that create a new instance per request.

pkg/inventory/server_tool_test.go

@@ -5,6 +5,7 @@ import (
 	"encoding/json"
 	"testing"
 
+	"github.com/google/jsonschema-go/jsonschema"
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -78,3 +79,23 @@ func TestNewServerToolWithContextHandler_ValidArguments_Succeeds(t *testing.T) {
 	require.True(t, ok)
 	assert.Equal(t, "success: octocat/hello-world", textContent.Text)
 }
+
+func TestAnnotateHeaderParams(t *testing.T) {
+	tool := &mcp.Tool{InputSchema: &jsonschema.Schema{
+		Type: "object",
+		Properties: map[string]*jsonschema.Schema{
+			"owner":  {Type: "string"},
+			"repo":   {Type: "string"},
+			"detail": {Type: "string"},
+		},
+	}}
+	annotateHeaderParams(tool)
+	schema := tool.InputSchema.(*jsonschema.Schema)
+	assert.Equal(t, "owner", schema.Properties["owner"].Extra["x-mcp-header"])
+	assert.Equal(t, "repo", schema.Properties["repo"].Extra["x-mcp-header"])
+	assert.Nil(t, schema.Properties["detail"].Extra)
+
+	// No-op for tools without owner/repo and when InputSchema is not a *jsonschema.Schema
+	annotateHeaderParams(&mcp.Tool{InputSchema: &jsonschema.Schema{Properties: map[string]*jsonschema.Schema{"x": {}}}})
+	annotateHeaderParams(&mcp.Tool{InputSchema: json.RawMessage(`{}`)})
+}