fix(gateway): drop mcpmux_describe_workspace meta tool

User feedback: the describe_* surface was redundant — `list_all_tools` and
`list_feature_sets` already give an LLM enough to introspect the resolved
state, and trimming the toolbar reduces visual noise on the client side.

* Remove `DescribeWorkspaceTool` from `tools.rs` and its registration in
  `meta_tools/mod.rs`.
* Drop the two `describe_workspace_*` integration tests; the resolver
  behavior they exercised is already covered by the
  `feature_set_resolver` integration suite.
* Re-target the audit-emission test to `mcpmux_list_all_tools` (still a
  read tool, same `decision = "read"` audit path).
* Update `registry_advertises_every_default_tool_with_annotations` to
  assert both describe_* tools are NOT advertised.

Signed-off-by: Mohammod Al Amin Ashik <maa.ashik00@gmail.com>

Author: its-mash

crates/mcpmux-gateway/src/services/meta_tools/mod.rs

@@ -77,11 +77,9 @@ pub fn build_default_registry(
     // Reads — no approval needed.
     registry.register(Box::new(tools::ListAllToolsTool));
     registry.register(Box::new(tools::ListFeatureSetsTool));
-    // `describe_workspace` also returns the resolution fields the older
-    // `describe_resolution` tool used to expose — the split was confusing
-    // for LLMs (two reads with overlapping output) and trimming it shrinks
-    // the toolbar visible to the caller.
-    registry.register(Box::new(tools::DescribeWorkspaceTool));
+    // Both `describe_resolution` and `describe_workspace` were removed by
+    // user request — the read surface is just the two list_* tools above,
+    // which an LLM can stitch into the same picture without an extra hop.
     // Writes — gated by ApprovalBroker.
     registry.register(Box::new(tools::CreateFeatureSetTool));
     registry.register(Box::new(tools::BindCurrentWorkspaceTool));

crates/mcpmux-gateway/src/services/meta_tools/tools.rs

@@ -154,95 +154,6 @@ impl MetaTool for ListFeatureSetsTool {
     }
 }
 
-// ---------------------------------------------------------------------------
-// mcpmux_describe_workspace — read
-//
-// Single read endpoint that combines:
-//   • workspace roots reported by the caller
-//   • the matched WorkspaceBinding (if any)
-//   • the resolved FeatureSet (id, name, source, tool count)
-// — replacing the older two-tool split where `describe_resolution` and
-// `describe_workspace` returned overlapping fragments.
-// ---------------------------------------------------------------------------
-
-pub struct DescribeWorkspaceTool;
-
-#[async_trait]
-impl MetaTool for DescribeWorkspaceTool {
-    fn name(&self) -> &'static str {
-        "mcpmux_describe_workspace"
-    }
-
-    fn description(&self) -> &'static str {
-        "Report everything that determines this caller's effective tool set: \
-         the workspace roots declared via MCP `roots`, the matched \
-         WorkspaceBinding (if any), and the resolved FeatureSet (id, name, \
-         source, tool count). Always call this before a write tool so you \
-         know the baseline."
-    }
-
-    fn input_schema(&self) -> Value {
-        json!({ "type": "object", "properties": {} })
-    }
-
-    async fn call(&self, call: MetaToolCall<'_>) -> Result<CallToolResult, MetaToolError> {
-        let space_id = caller_space_id(&call).await?;
-        let roots = call
-            .session_id
-            .and_then(|sid| call.ctx.session_roots.get(sid))
-            .unwrap_or_default();
-        let matched = if !roots.is_empty() {
-            call.ctx
-                .binding_repo
-                .find_longest_prefix_match(&space_id, &roots)
-                .await?
-        } else {
-            None
-        };
-
-        // Walk the resolver too — that's the authoritative answer for "which
-        // FS would actually apply right now". A binding may exist but the
-        // caller's resolution chain may still pick something else (e.g. a
-        // session pin, when those exist again).
-        let resolved = call.ctx.resolver.resolve(call.session_id).await?;
-        let fs_id = resolved.feature_set_id.clone();
-        let fs_name = if let Some(id) = fs_id.as_deref() {
-            call.ctx.feature_set_repo.get(id).await?.map(|fs| fs.name)
-        } else {
-            None
-        };
-        let tool_count = if let Some(id) = fs_id.as_deref() {
-            let resolved_space = resolved.space_id.unwrap_or(space_id);
-            call.ctx
-                .feature_service
-                .get_tools_for_grants(&resolved_space.to_string(), &[id.to_string()])
-                .await?
-                .iter()
-                .filter(|f| f.is_available)
-                .count()
-        } else {
-            0
-        };
-
-        Ok(text_result(json!({
-            "space_id": space_id,
-            "reported_roots": roots,
-            "matched_binding": matched.map(|b| json!({
-                "id": b.id,
-                "workspace_root": b.workspace_root,
-                "space_id": b.space_id,
-                "feature_set_id": b.feature_set_id,
-            })),
-            "resolution": {
-                "feature_set_id": fs_id,
-                "feature_set_name": fs_name,
-                "source": resolved.source,
-                "resolved_tool_count": tool_count,
-            },
-        })))
-    }
-}
-
 // ---------------------------------------------------------------------------
 // Writes — each goes through the ApprovalBroker before mutating state.
 // ---------------------------------------------------------------------------

tests/rust/tests/integration/meta_tools.rs

@@ -248,68 +248,11 @@ async fn list_feature_sets_returns_space_contents() {
     assert_eq!(sets.len(), 3, "Default + 2 custom expected");
 }
 
-#[tokio::test(flavor = "multi_thread")]
-async fn describe_workspace_reports_default_resolution() {
-    // With no bindings and no reported roots, the resolver falls through
-    // to the Default tier and returns the space's auto-seeded
-    // `fs_default_<space>` FS. `describe_workspace` surfaces this in its
-    // `resolution` block (the field used to live on a separate
-    // `describe_resolution` tool that we collapsed into this one).
-    let f = Fixture::new().await;
-    let result = f
-        .registry
-        .call(
-            "mcpmux_describe_workspace",
-            &f.client_id,
-            Some(&f.session_id),
-            json!({}),
-        )
-        .await
-        .unwrap();
-    let body = Fixture::result_json(&result);
-    let resolution = body.get("resolution").unwrap();
-    assert_eq!(
-        resolution.get("source").unwrap().as_str().unwrap(),
-        "default"
-    );
-    let fs_id = resolution.get("feature_set_id").unwrap().as_str().unwrap();
-    assert!(
-        fs_id.starts_with("fs_default_"),
-        "default tier should surface the Default FS, got {fs_id}"
-    );
-}
-
-#[tokio::test(flavor = "multi_thread")]
-async fn describe_workspace_reports_reported_roots() {
-    let f = Fixture::new().await;
-    let path = if cfg!(windows) {
-        "d:\\android\\myapp"
-    } else {
-        "/android/myapp"
-    };
-    f.session_roots.set(&f.session_id, [path]);
-
-    let result = f
-        .registry
-        .call(
-            "mcpmux_describe_workspace",
-            &f.client_id,
-            Some(&f.session_id),
-            json!({}),
-        )
-        .await
-        .unwrap();
-    let body = Fixture::result_json(&result);
-    let roots = body.get("reported_roots").unwrap().as_array().unwrap();
-    assert_eq!(roots.len(), 1);
-    assert!(body.get("matched_binding").unwrap().is_null());
-    // Resolution still reports the default tier — no binding matched.
-    let resolution = body.get("resolution").unwrap();
-    assert_eq!(
-        resolution.get("source").unwrap().as_str().unwrap(),
-        "default"
-    );
-}
+// `describe_resolution` and `describe_workspace` were both removed at the
+// user's request — the read surface is now just `list_all_tools` and
+// `list_feature_sets`. Behavior previously asserted here is covered by
+// `FeatureSetResolverService`'s own tests in
+// `tests/rust/tests/integration/feature_set_resolver.rs`.
 
 // ---------------------------------------------------------------------------
 // Writes — gated by ApprovalBroker
@@ -490,18 +433,18 @@ async fn registry_advertises_every_default_tool_with_annotations() {
     for expected in [
         "mcpmux_list_all_tools",
         "mcpmux_list_feature_sets",
-        "mcpmux_describe_workspace",
         "mcpmux_create_feature_set",
         "mcpmux_bind_current_workspace",
     ] {
         assert!(names.iter().any(|n| n == expected), "missing {expected}");
     }
-    // describe_resolution was collapsed into describe_workspace — the
-    // registry must NOT advertise it any more.
-    assert!(
-        !names.iter().any(|n| n == "mcpmux_describe_resolution"),
-        "describe_resolution should be removed; got {names:?}"
-    );
+    // Both describe_* tools were removed — they must NOT be advertised.
+    for removed in ["mcpmux_describe_resolution", "mcpmux_describe_workspace"] {
+        assert!(
+            !names.iter().any(|n| n == removed),
+            "{removed} should be removed; got {names:?}"
+        );
+    }
     // Writes carry the destructive_hint annotation.
     let bind = tools
         .iter()
@@ -577,12 +520,7 @@ async fn read_tool_emits_meta_tool_invoked_with_decision_read() {
     let (registry, client_id, _tx, mut rx) = bare_registry(None).await;
 
     registry
-        .call(
-            "mcpmux_describe_workspace",
-            &client_id,
-            Some("s"),
-            json!({}),
-        )
+        .call("mcpmux_list_all_tools", &client_id, Some("s"), json!({}))
         .await
         .unwrap();
 
@@ -596,7 +534,7 @@ async fn read_tool_emits_meta_tool_invoked_with_decision_read() {
             decision,
             ..
         } => {
-            assert_eq!(tool_name, "mcpmux_describe_workspace");
+            assert_eq!(tool_name, "mcpmux_list_all_tools");
             assert_eq!(decision, "read");
         }
         other => panic!("unexpected event: {other:?}"),