decentraland · dalkia · Aug 7, 2026 · Jul 21, 2026 · Jul 24, 2026 · Aug 3, 2026
@@ -1005,7 +1005,8 @@ await MapRendererContainer
                     bootstrapContainer.DiagnosticsContainer,
                     staticContainer.InputBlock,
                     assetsProvisioner,
-                    debugBuilder
+                    debugBuilder,
+                    staticContainer.ScenesCache
                 ));
 
             if (!localSceneDevelopment)

@@ -299,6 +299,7 @@ public UniTask InitializeAsync(StaticSettings settings, CancellationToken ct)
                 new AssetsCollidersPlugin(sharedDependencies),
                 new AvatarShapePlugin(globalWorld, componentsContainer.ComponentPoolsRegistry, launchMode, useRemoteAssetBundles),
                 new PrimitivesRenderingPlugin(sharedDependencies),
+                new SceneContentStatsPlugin(),
                 new VisibilityPlugin(),
                 new AudioSourcesPlugin(sharedDependencies, container.WebRequestsContainer.WebRequestController, container.CacheCleaner, container.assetsProvisioner),
                 new AudioAnalysisPlugin(sharedDependencies),

@@ -153,7 +153,7 @@ public SceneInstanceDependencies(
             /* Pass dependencies here if they are needed by the systems */
             ecsWorldSharedDependencies = new ECSWorldInstanceSharedDependencies(sceneData, partitionProvider, ecsToCRDTWriter, entitiesMap,
                 ExceptionsHandler, EntityCollidersCache, SceneStateProvider, entityEventsBuilder, ecsMultiThreadSync,
-                systemGroupThrottler, systemsUpdateGate);
+                systemGroupThrottler, systemsUpdateGate, RuntimeMetrics);
 
             ECSWorldFacade = ecsWorldFactory.CreateWorld(new ECSWorldFactoryArgs(ecsWorldSharedDependencies, systemGroupThrottler, sceneData));
             CRDTWorldSynchronizer = new CRDTWorldSynchronizer(ECSWorldFacade.EcsWorld, sdkComponentsRegistry, entityFactory, entitiesMap);

@@ -120,6 +120,9 @@ public void InjectToWorld(ref ArchSystemsWorldBuilder<Arch.Core.World> builder,
                           .Add(screenshotTool)
                           .Add(new GetPlayerStateTool(globalWorld, arguments.PlayerEntity, exposedCameraData, currentSceneInfo))
                           .Add(new GetSceneStateTool(scenesCache, currentSceneInfo, loadingStatus, localSceneDevelopment))
+                          .Add(new GetSceneContentStatsTool(scenesCache))
+                          .Add(new GetSceneContentBreakdownTool(scenesCache))
+                          .Add(new GetPerformanceStatsTool(scenesCache))
                           .Add(new GetSceneLogsTool(logBuffer))
                           .Add(new TeleportTool(chatMessagesBus, scenesCache, loadingStatus))
                           .Add(new MoveToTool(globalWorldActions, globalWorld, arguments.PlayerEntity))

@@ -0,0 +1,85 @@
+using DCL.McpServer.Core;
+using DCL.McpServer.Tools;
+using DCL.Profiling;
+using DCL.Utilities;
+using ECS.SceneLifeCycle;
+using Newtonsoft.Json.Linq;
+using NSubstitute;
+using NUnit.Framework;
+using SceneRunner.Scene;
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+
+namespace DCL.McpServer.Tests
+{
+    public class GetSceneContentBreakdownToolShould
+    {
+        private IScenesCache scenesCache = null!;
+        private ISceneFacade scene = null!;
+        private SceneRuntimeMetrics runtimeMetrics = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            runtimeMetrics = new SceneRuntimeMetrics();
+
+            ISceneData sceneData = Substitute.For<ISceneData>();
+            sceneData.Parcels.Returns(new List<Vector2Int> { new (0, 0), new (0, 1) });
+
+            scene = Substitute.For<ISceneFacade>();
+            scene.SceneData.Returns(sceneData);
+            scene.RuntimeMetrics.Returns(runtimeMetrics);
+
+            scenesCache = Substitute.For<IScenesCache>();
+            scenesCache.CurrentScene.Returns(new ReactiveProperty<ISceneFacade?>(scene));
+        }
+
+        [Test]
+        public void ErrorWhenNoSceneIsLoaded()
+        {
+            // Arrange
+            scenesCache.CurrentScene.Returns(new ReactiveProperty<ISceneFacade?>(null));
+            var tool = new GetSceneContentBreakdownTool(scenesCache, collectionTimeoutMs: 0);
+
+            // Act
+            McpToolResult result = Execute(tool);
+
+            // Assert
+            Assert.That(result.Payload["isError"]!.Value<bool>(), Is.True);
+        }
+
+        [Test]
+        public void ClearBothDemandFlagsWhenNoPassArrives()
+        {
+            // Arrange — the zero timeout skips the wait, so no fresh pass lands and the tool errors;
+            // the cleanup finally must still reset both the breakdown request and the MCP demand flag.
+            var tool = new GetSceneContentBreakdownTool(scenesCache, collectionTimeoutMs: 0);
+
+            // Act
+            McpToolResult result = Execute(tool);
+
+            // Assert
+            Assert.That(result.Payload["isError"]!.Value<bool>(), Is.True);
+            Assert.That(runtimeMetrics.ContentStats.BreakdownRequested, Is.False);
+            Assert.That(runtimeMetrics.ContentStats.RequestedByMcp, Is.False);
+        }
+
+        [Test]
+        public void DeclareLimitAndSortByInTheInputSchema()
+        {
+            // Arrange
+            var tool = new GetSceneContentBreakdownTool(scenesCache);
+
+            // Act
+            var properties = (JObject)tool.InputSchema["properties"]!;
+
+            // Assert
+            Assert.That(properties["limit"], Is.Not.Null);
+            Assert.That(properties["sortBy"], Is.Not.Null);
+        }
+
+        private static McpToolResult Execute(GetSceneContentBreakdownTool tool) =>
+            tool.ExecuteAsync(new JObject(), CancellationToken.None).GetAwaiter().GetResult();
+    }
+}
@@ -0,0 +1,117 @@
+using DCL.McpServer.Core;
+using DCL.McpServer.Tools;
+using DCL.Profiling;
+using DCL.Utilities;
+using ECS.SceneLifeCycle;
+using Newtonsoft.Json.Linq;
+using NSubstitute;
+using NUnit.Framework;
+using SceneRunner.Scene;
+using System.Collections.Generic;
+using System.Threading;
+using UnityEngine;
+
+namespace DCL.McpServer.Tests
+{
+    public class GetSceneContentStatsToolShould
+    {
+        private IScenesCache scenesCache = null!;
+        private ISceneFacade scene = null!;
+        private SceneRuntimeMetrics runtimeMetrics = null!;
+
+        [SetUp]
+        public void Setup()
+        {
+            runtimeMetrics = new SceneRuntimeMetrics();
+
+            ISceneData sceneData = Substitute.For<ISceneData>();
+            sceneData.Parcels.Returns(new List<Vector2Int> { new (0, 0), new (0, 1) });
+
+            scene = Substitute.For<ISceneFacade>();
+            scene.SceneData.Returns(sceneData);
+            scene.RuntimeMetrics.Returns(runtimeMetrics);
+
+            scenesCache = Substitute.For<IScenesCache>();
+            scenesCache.CurrentScene.Returns(new ReactiveProperty<ISceneFacade?>(scene));
+        }
+
+        [Test]
+        public void ErrorWhenNoSceneIsLoaded()
+        {
+            // Arrange
+            scenesCache.CurrentScene.Returns(new ReactiveProperty<ISceneFacade?>(null));
+            var tool = new GetSceneContentStatsTool(scenesCache, collectionTimeoutMs: 0);
+
+            // Act
+            McpToolResult result = Execute(tool);
+
+            // Assert
+            Assert.That(result.Payload["isError"]!.Value<bool>(), Is.True);
+        }
+
+        [Test]
+        public void ErrorWhenTheSceneNeverProducedStats()
+        {
+            // Arrange — HasData stays false and the zero timeout skips waiting for a pass
+            var tool = new GetSceneContentStatsTool(scenesCache, collectionTimeoutMs: 0);
+
+            // Act
+            McpToolResult result = Execute(tool);
+
+            // Assert
+            Assert.That(result.Payload["isError"]!.Value<bool>(), Is.True);
+            Assert.That(runtimeMetrics.ContentStats.RequestedByMcp, Is.False);
+        }
+
+        [Test]
+        public void ReportStatsWithCapsMatchingTheOutputSchema()
+        {
+            // Arrange
+            SceneContentStats stats = runtimeMetrics.ContentStats;
+            stats.HasData = true;
+            stats.Entities = 10;
+            stats.Triangles = 5200;
+            stats.Bodies = 12;
+            stats.Geometries = 7;
+            stats.Materials = 5;
+            stats.Textures = 3;
+            stats.ShaderVariants = 2;
+            stats.Colliders = 2;
+            stats.Videos = 1;
+
+            var tool = new GetSceneContentStatsTool(scenesCache, collectionTimeoutMs: 0);
+
+            // Act
+            var structured = (JObject)Execute(tool).Payload["structuredContent"]!;
+
+            // Assert
+            McpSchemaAssert.KeysMatch(tool.OutputSchema, structured);
+            Assert.That(structured["parcelCount"]!.Value<int>(), Is.EqualTo(2));
+            Assert.That(structured["fresh"]!.Value<bool>(), Is.False);
+            Assert.That(structured["entities"]!.Value<int>(), Is.EqualTo(10));
+            Assert.That(structured["entitiesCap"]!.Value<int>(), Is.EqualTo(400));
+            Assert.That(structured["triangles"]!.Value<long>(), Is.EqualTo(5200));
+            Assert.That(structured["trianglesCap"]!.Value<long>(), Is.EqualTo(20000));
+            Assert.That(structured["geometries"]!.Value<int>(), Is.EqualTo(7));
+            Assert.That(structured["shaderVariants"]!.Value<int>(), Is.EqualTo(2));
+            Assert.That(structured["videos"]!.Value<int>(), Is.EqualTo(1));
+        }
+
+        [Test]
+        public void ClearTheDemandFlagAfterReporting()
+        {
+            // Arrange
+            runtimeMetrics.ContentStats.HasData = true;
+            var tool = new GetSceneContentStatsTool(scenesCache, collectionTimeoutMs: 0);
+
+            // Act
+            Execute(tool);
+
+            // Assert
+            Assert.That(runtimeMetrics.ContentStats.RequestedByMcp, Is.False);
+        }
+
+        private static McpToolResult Execute(GetSceneContentStatsTool tool) =>
+            tool.ExecuteAsync(new JObject(), CancellationToken.None).GetAwaiter().GetResult();
+    }
+}