fix: accept omitted tool arguments for zero-param tools like get_me

When MCP clients omit the arguments field on tools/call, the typed tool
wrapper received nil RawMessage and failed JSON unmarshaling before the
handler ran. Coerce nil or empty arguments to {} so zero-parameter tools
such as get_me work as documented.

Closes #2587

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: advancedresearcharray

pkg/github/context_tools_test.go

@@ -139,6 +139,48 @@ func Test_GetMe(t *testing.T) {
 	}
 }
 
+func Test_GetMe_OmittedArguments(t *testing.T) {
+	t.Parallel()
+
+	serverTool := GetMe(translations.NullTranslationHelper)
+
+	mockUser := &github.User{
+		Login:     github.Ptr("testuser"),
+		Name:      github.Ptr("Test User"),
+		HTMLURL:   github.Ptr("https://github.com/testuser"),
+		CreatedAt: &github.Timestamp{Time: time.Now()},
+	}
+	mockedClient := MockHTTPClientWithHandlers(map[string]http.HandlerFunc{
+		GetUser: mockResponse(t, http.StatusOK, mockUser),
+	})
+	deps := BaseDeps{Client: mustNewGHClient(t, mockedClient), Obsv: stubExporters()}
+	handler := serverTool.Handler(deps)
+
+	tests := []struct {
+		name      string
+		arguments json.RawMessage
+	}{
+		{name: "nil arguments", arguments: nil},
+		{name: "empty byte slice", arguments: json.RawMessage{}},
+		{name: "explicit empty object", arguments: json.RawMessage(`{}`)},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			request := createMCPRequestWithRawArguments(tc.arguments)
+			result, err := handler(ContextWithDeps(context.Background(), deps), &request)
+			require.NoError(t, err)
+			require.False(t, result.IsError)
+
+			textContent := getTextResult(t, result)
+			var returnedUser MinimalUser
+			err = json.Unmarshal([]byte(textContent.Text), &returnedUser)
+			require.NoError(t, err)
+			assert.Equal(t, "testuser", returnedUser.Login)
+		})
+	}
+}
+
 func Test_GetMe_IFC_FeatureFlag(t *testing.T) {
 	t.Parallel()
 

pkg/github/helper_test.go

@@ -323,6 +323,16 @@ func createMCPRequest(args any) mcp.CallToolRequest {
 	}
 }
 
+// createMCPRequestWithRawArguments creates a CallToolRequest with the given raw JSON arguments.
+// Use nil or an empty slice to simulate clients that omit the arguments field.
+func createMCPRequestWithRawArguments(args json.RawMessage) mcp.CallToolRequest {
+	return mcp.CallToolRequest{
+		Params: &mcp.CallToolParamsRaw{
+			Arguments: args,
+		},
+	}
+}
+
 // Well-known MCP client names used in tests.
 const (
 	ClientNameVSCodeInsiders = "Visual Studio Code - Insiders"

pkg/inventory/server_tool.go

@@ -133,7 +133,12 @@ func NewServerToolWithContextHandler[In any, Out any](tool mcp.Tool, toolset Too
 		HandlerFunc: func(_ any) mcp.ToolHandler {
 			return func(ctx context.Context, req *mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 				var arguments In
-				if err := json.Unmarshal(req.Params.Arguments, &arguments); err != nil {
+				args := req.Params.Arguments
+				// Some MCP clients omit arguments for zero-parameter tools; treat as {}.
+				if len(args) == 0 {
+					args = json.RawMessage(`{}`)
+				}
+				if err := json.Unmarshal(args, &arguments); err != nil {
 					return &mcp.CallToolResult{
 						Content: []mcp.Content{
 							&mcp.TextContent{Text: fmt.Sprintf("invalid arguments: %s", err)},

pkg/inventory/server_tool_test.go

@@ -78,3 +78,93 @@ func TestNewServerToolWithContextHandler_ValidArguments_Succeeds(t *testing.T) {
 	require.True(t, ok)
 	assert.Equal(t, "success: octocat/hello-world", textContent.Text)
 }
+
+func TestNewServerToolWithContextHandler_EmptyArguments_TreatedAsEmptyObject(t *testing.T) {
+	tool := NewServerToolWithContextHandler(
+		mcp.Tool{Name: "zero_arg_tool"},
+		testToolsetMetadata("test"),
+		func(_ context.Context, _ *mcp.CallToolRequest, args map[string]any) (*mcp.CallToolResult, any, error) {
+			if len(args) != 0 {
+				return &mcp.CallToolResult{
+					Content: []mcp.Content{
+						&mcp.TextContent{Text: "expected empty arguments"},
+					},
+					IsError: true,
+				}, nil, nil
+			}
+			return &mcp.CallToolResult{
+				Content: []mcp.Content{
+					&mcp.TextContent{Text: "ok"},
+				},
+			}, args, nil
+		},
+	)
+
+	handler := tool.HandlerFunc(nil)
+
+	tests := []struct {
+		name      string
+		arguments json.RawMessage
+	}{
+		{name: "nil arguments", arguments: nil},
+		{name: "empty byte slice", arguments: json.RawMessage{}},
+		{name: "explicit empty object", arguments: json.RawMessage(`{}`)},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := handler(context.Background(), &mcp.CallToolRequest{
+				Params: &mcp.CallToolParamsRaw{
+					Name:      "zero_arg_tool",
+					Arguments: tt.arguments,
+				},
+			})
+
+			require.NoError(t, err)
+			require.NotNil(t, result)
+			assert.False(t, result.IsError)
+		})
+	}
+}
+
+func TestNewServerToolWithContextHandler_EmptyArguments_TypedEmptyStruct(t *testing.T) {
+	type emptyArgs struct{}
+
+	tool := NewServerToolWithContextHandler(
+		mcp.Tool{Name: "typed_zero_arg_tool"},
+		testToolsetMetadata("test"),
+		func(_ context.Context, _ *mcp.CallToolRequest, args emptyArgs) (*mcp.CallToolResult, any, error) {
+			return &mcp.CallToolResult{
+				Content: []mcp.Content{
+					&mcp.TextContent{Text: "ok"},
+				},
+			}, args, nil
+		},
+	)
+
+	handler := tool.HandlerFunc(nil)
+
+	tests := []struct {
+		name      string
+		arguments json.RawMessage
+	}{
+		{name: "nil arguments", arguments: nil},
+		{name: "empty byte slice", arguments: json.RawMessage{}},
+		{name: "explicit empty object", arguments: json.RawMessage(`{}`)},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := handler(context.Background(), &mcp.CallToolRequest{
+				Params: &mcp.CallToolParamsRaw{
+					Name:      "typed_zero_arg_tool",
+					Arguments: tt.arguments,
+				},
+			})
+
+			require.NoError(t, err)
+			require.NotNil(t, result)
+			assert.False(t, result.IsError)
+		})
+	}
+}