test(gateway): cover invoke filter shaping with unit and e2e tests

Add InvokeToolBackend for pluggable routing, expand filter unit tests,
and prove mcpmux_invoke_tool applies filters via CannedInvokeBackend.
Reconcile Phase B planning docs after manual github_list_issues pass.

Signed-off-by: crimsonsunset <jsangio1@gmail.com>

Author: crimsonsunset

crates/mcpmux-gateway/src/lib.rs

@@ -70,13 +70,17 @@ pub use pool::{
     ServerState,
     ServiceFactory,
     TokenService,
+    ToolCallResult,
     TransportConnectResult,
     TransportFactory,
     TransportType,
 };
 
 // Services module
-pub use services::{EventEmitter, GrantService, PrefixCacheService, SessionOverrideRegistry};
+pub use services::{
+    EventEmitter, GrantService, InvokeToolBackend, PrefixCacheService, SessionOverrideRegistry,
+    routing_as_invoke_backend,
+};
 
 // MCP module (rmcp-based implementation)
 pub use mcp::McpMuxGatewayHandler;

crates/mcpmux-gateway/src/pool/mod.rs

@@ -44,7 +44,7 @@ pub use connection::{ConnectionResult, ConnectionService};
 pub use features::{CachedFeatures, FeatureService};
 pub use routing::{
     format_direct_call_redirect, format_invoke_permission_denied, format_server_inactive_error,
-    RoutedPrompt, RoutedResource, RoutedTool, RoutingService,
+    RoutedPrompt, RoutedResource, RoutedTool, RoutingService, ToolCallResult,
 };
 pub use service::{InstalledServerInfo, PoolService, PoolStats, ReconnectResult};
 pub use token::TokenService;

crates/mcpmux-gateway/src/pool/routing.rs

@@ -48,7 +48,7 @@ pub struct RoutedResource {
 }
 
 /// Result of a tool call
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ToolCallResult {
     pub content: Vec<Value>,
     pub structured_content: Option<Value>,

crates/mcpmux-gateway/src/server/service_container.rs

@@ -134,7 +134,9 @@ impl ServiceContainer {
             deps.installed_server_repo.clone(),
             feature_set_resolver.clone(),
             pool_services.feature_service.clone(),
-            Some(pool_services.routing_service.clone()),
+            Some(meta_tools::routing_as_invoke_backend(
+                pool_services.routing_service.clone(),
+            )),
             session_roots.clone(),
             session_overrides.clone(),
             approval_broker.clone(),

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

@@ -131,7 +131,7 @@ impl MetaTool for InvokeToolTool {
                         "format": {
                             "type": "string",
                             "enum": ["summary", "full"],
-                            "description": "summary keeps metadata plus a bounded sample; full returns truncated rows"
+                            "description": "When max_rows is set: summary caps the sample at min(max_rows, 5); full returns up to max_rows rows. Ignored when max_rows is omitted."
                         }
                     }
                 }
@@ -246,12 +246,12 @@ impl MetaTool for InvokeToolTool {
             )));
         }
 
-        let routing = call
+        let backend = call
             .ctx
-            .routing_service
+            .invoke_backend
             .as_ref()
             .ok_or_else(|| MetaToolError::Internal("invoke routing not configured".into()))?;
-        match routing
+        match backend
             .call_tool(
                 space_id,
                 &resolved.feature_set_ids,
@@ -473,6 +473,18 @@ fn invoke_error(message: String) -> CallToolResult {
 mod tests {
     use super::*;
 
+    fn issue_rows(count: usize) -> Vec<Value> {
+        (0..count)
+            .map(|i| {
+                json!({
+                    "id": i,
+                    "title": format!("issue-{i}"),
+                    "body": format!("body-{i}")
+                })
+            })
+            .collect()
+    }
+
     #[test]
     fn no_filter_passes_through_large_array() {
         let items: Vec<Value> = (0..100).map(|i| json!({ "id": i, "name": format!("n{i}") })).collect();
@@ -481,8 +493,8 @@ mod tests {
     }
 
     #[test]
-    fn explicit_max_rows_truncates() {
-        let items: Vec<Value> = (0..20).map(|i| json!({ "id": i })).collect();
+    fn explicit_max_rows_truncates_top_level_array() {
+        let items: Vec<Value> = issue_rows(20);
         let filter = InvokeResultFilter {
             max_rows: Some(3),
             ..Default::default()
@@ -491,6 +503,70 @@ mod tests {
         assert_eq!(shaped.get("returned"), Some(&json!(3)));
         assert_eq!(shaped.get("total"), Some(&json!(20)));
         assert_eq!(shaped.get("truncated"), Some(&json!(true)));
+        let sample = shaped.get("items").and_then(|v| v.as_array()).unwrap();
+        assert_eq!(sample.len(), 3);
+    }
+
+    #[test]
+    fn explicit_max_rows_truncates_nested_issues_key() {
+        let issues = issue_rows(20);
+        let filter = InvokeResultFilter {
+            max_rows: Some(3),
+            ..Default::default()
+        };
+        let shaped = shape_json_value(json!({ "issues": issues }), &filter);
+        assert_eq!(shaped.get("returned"), Some(&json!(3)));
+        assert_eq!(shaped.get("total"), Some(&json!(20)));
+        assert_eq!(shaped.get("truncated"), Some(&json!(true)));
+        let sample = shaped.get("issues").and_then(|v| v.as_array()).unwrap();
+        assert_eq!(sample.len(), 3);
+    }
+
+    #[test]
+    fn json_in_text_block_truncates_with_metadata() {
+        let rows: Vec<Value> = (0..80).map(|i| json!({ "n": i })).collect();
+        let content = vec![json!({
+            "type": "text",
+            "text": json!({ "results": rows }).to_string(),
+        })];
+        let filter = parse_invoke_filter(Some(&json!({ "max_rows": 10 }))).unwrap();
+
+        let (shaped_content, _) = apply_invoke_result_filter(content, None, &filter);
+        let text = shaped_content[0].get("text").and_then(|t| t.as_str()).unwrap();
+        let parsed: Value = serde_json::from_str(text).unwrap();
+
+        assert_eq!(parsed.get("returned"), Some(&json!(10)));
+        assert_eq!(parsed.get("total"), Some(&json!(80)));
+        assert_eq!(parsed.get("truncated"), Some(&json!(true)));
+    }
+
+    #[test]
+    fn structured_content_and_text_both_shaped() {
+        let items = issue_rows(20);
+        let structured = json!({ "items": items });
+        let content = vec![json!({
+            "type": "text",
+            "text": structured.to_string(),
+        })];
+        let filter = InvokeResultFilter {
+            max_rows: Some(5),
+            fields: Some(vec!["id".into(), "title".into()]),
+            ..Default::default()
+        };
+
+        let (shaped_content, shaped_structured) =
+            apply_invoke_result_filter(content, Some(structured), &filter);
+
+        let parsed_text: Value =
+            serde_json::from_str(shaped_content[0].get("text").and_then(|t| t.as_str()).unwrap())
+                .unwrap();
+        assert_eq!(parsed_text.get("returned"), Some(&json!(5)));
+        assert_eq!(parsed_text.get("total"), Some(&json!(20)));
+
+        let shaped = shaped_structured.unwrap();
+        let structured_sample = shaped.get("items").and_then(|v| v.as_array()).unwrap();
+        assert_eq!(structured_sample.len(), 5);
+        assert_eq!(structured_sample[0], json!({ "id": 0, "title": "issue-0" }));
     }
 
     #[test]
@@ -509,6 +585,83 @@ mod tests {
         assert_eq!(kept[1], json!({ "id": 2, "name": "b" }));
     }
 
+    #[test]
+    fn max_rows_and_fields_together() {
+        let items: Vec<Value> = (0..30)
+            .map(|i| json!({ "id": i, "label": format!("row-{i}") }))
+            .collect();
+        let filter = parse_invoke_filter(Some(&json!({ "max_rows": 5, "fields": ["id"] }))).unwrap();
+        let shaped = shape_json_value(Value::Array(items), &filter);
+
+        assert_eq!(shaped.get("returned"), Some(&json!(5)));
+        assert_eq!(shaped.get("total"), Some(&json!(30)));
+        assert_eq!(shaped.get("truncated"), Some(&json!(true)));
+        let sample = shaped.get("items").and_then(|v| v.as_array()).unwrap();
+        assert_eq!(sample.len(), 5);
+        assert_eq!(sample[0], json!({ "id": 0 }));
+    }
+
+    #[test]
+    fn summary_format_no_op_when_max_rows_at_most_five() {
+        let items = issue_rows(20);
+        let filter = InvokeResultFilter {
+            max_rows: Some(3),
+            format: Some("summary".into()),
+            ..Default::default()
+        };
+        let shaped = shape_json_value(Value::Array(items), &filter);
+        assert_eq!(shaped.get("returned"), Some(&json!(3)));
+    }
+
+    #[test]
+    fn summary_format_caps_sample_at_five() {
+        let items = issue_rows(20);
+        let filter = InvokeResultFilter {
+            max_rows: Some(10),
+            format: Some("summary".into()),
+            ..Default::default()
+        };
+        let shaped = shape_json_value(Value::Array(items), &filter);
+        assert_eq!(shaped.get("returned"), Some(&json!(5)));
+        assert_eq!(shaped.get("total"), Some(&json!(20)));
+    }
+
+    #[test]
+    fn full_format_returns_up_to_max_rows() {
+        let items = issue_rows(20);
+        let filter = InvokeResultFilter {
+            max_rows: Some(10),
+            format: Some("full".into()),
+            ..Default::default()
+        };
+        let shaped = shape_json_value(Value::Array(items), &filter);
+        assert_eq!(shaped.get("returned"), Some(&json!(10)));
+        let sample = shaped.get("items").and_then(|v| v.as_array()).unwrap();
+        assert_eq!(sample.len(), 10);
+    }
+
+    #[test]
+    fn parse_invoke_filter_ignores_invalid_types() {
+        let filter = parse_invoke_filter(Some(&json!({
+            "max_rows": "not-a-number",
+            "max_bytes": true,
+            "fields": "id",
+            "format": 123
+        })))
+        .unwrap();
+        assert_eq!(filter.max_rows, None);
+        assert_eq!(filter.max_bytes, None);
+        assert_eq!(filter.fields, None);
+        assert_eq!(filter.format, None);
+    }
+
+    #[test]
+    fn parse_invoke_filter_accepts_partial_objects() {
+        let filter = parse_invoke_filter(Some(&json!({ "max_rows": 3 }))).unwrap();
+        assert_eq!(filter.max_rows, Some(3));
+        assert_eq!(filter.max_bytes, None);
+    }
+
     #[test]
     fn plain_text_byte_trunc_includes_metadata() {
         let text = "x".repeat(100);

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

@@ -0,0 +1,51 @@
+//! Pluggable backend for `mcpmux_invoke_tool` routing.
+
+use std::sync::Arc;
+
+use anyhow::Result;
+use async_trait::async_trait;
+use serde_json::Value;
+use uuid::Uuid;
+
+use crate::pool::{RoutingService, ToolCallResult};
+
+/// Dispatches permission-checked tool calls to a backend MCP server.
+#[async_trait]
+pub trait InvokeToolBackend: Send + Sync {
+    /// Invoke a qualified backend tool and return raw MCP content.
+    async fn call_tool(
+        &self,
+        space_id: Uuid,
+        feature_set_ids: &[String],
+        session_id: Option<&str>,
+        qualified_name: &str,
+        arguments: Value,
+    ) -> Result<ToolCallResult>;
+}
+
+#[async_trait]
+impl InvokeToolBackend for RoutingService {
+    async fn call_tool(
+        &self,
+        space_id: Uuid,
+        feature_set_ids: &[String],
+        session_id: Option<&str>,
+        qualified_name: &str,
+        arguments: Value,
+    ) -> Result<ToolCallResult> {
+        RoutingService::call_tool(
+            self,
+            space_id,
+            feature_set_ids,
+            session_id,
+            qualified_name,
+            arguments,
+        )
+        .await
+    }
+}
+
+/// Wrap a [`RoutingService`] as an [`InvokeToolBackend`] trait object.
+pub fn routing_as_invoke_backend(routing: Arc<RoutingService>) -> Arc<dyn InvokeToolBackend> {
+    routing
+}

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

@@ -23,6 +23,7 @@
 pub mod approval;
 pub mod diff;
 pub mod invoke;
+pub mod invoke_backend;
 mod registry;
 mod tools;
 mod workspace_server;
@@ -32,6 +33,7 @@ pub use approval::{
     ApprovalScope,
 };
 pub use diff::ToolDiff;
+pub use invoke_backend::{routing_as_invoke_backend, InvokeToolBackend};
 pub use registry::{
     MetaToolContext, MetaToolError, MetaToolRegistry, META_TOOLS_ENABLED_KEY,
     SESSION_OVERRIDES_REQUIRE_APPROVAL_KEY,
@@ -62,7 +64,7 @@ pub fn build_default_registry(
     installed_server_repo: std::sync::Arc<dyn mcpmux_core::InstalledServerRepository>,
     resolver: std::sync::Arc<crate::services::FeatureSetResolverService>,
     feature_service: std::sync::Arc<crate::pool::FeatureService>,
-    routing_service: Option<std::sync::Arc<crate::pool::RoutingService>>,
+    invoke_backend: Option<std::sync::Arc<dyn invoke_backend::InvokeToolBackend>>,
     session_roots: std::sync::Arc<crate::services::SessionRootsRegistry>,
     session_overrides: std::sync::Arc<crate::services::SessionOverrideRegistry>,
     approval_broker: std::sync::Arc<ApprovalBroker>,
@@ -80,7 +82,7 @@ pub fn build_default_registry(
         installed_server_repo,
         resolver,
         feature_service,
-        routing_service,
+        invoke_backend,
         tool_discovery,
         session_roots,
         session_overrides,

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

@@ -18,7 +18,8 @@ use thiserror::Error;
 use tokio::sync::broadcast;
 
 use super::approval::ApprovalBroker;
-use crate::pool::{FeatureService, RoutingService};
+use super::invoke_backend::InvokeToolBackend;
+use crate::pool::FeatureService;
 use crate::services::{
     FeatureSetResolverService, SessionOverrideRegistry, SessionRootsRegistry, ToolDiscoveryService,
 };
@@ -47,7 +48,7 @@ pub struct MetaToolContext {
     pub resolver: Arc<FeatureSetResolverService>,
     pub feature_service: Arc<FeatureService>,
     /// Backend invoke path — required for `mcpmux_invoke_tool`.
-    pub routing_service: Option<Arc<RoutingService>>,
+    pub invoke_backend: Option<Arc<dyn InvokeToolBackend>>,
     pub tool_discovery: Arc<ToolDiscoveryService>,
     pub session_roots: Arc<SessionRootsRegistry>,
     pub session_overrides: Arc<SessionOverrideRegistry>,

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

@@ -24,8 +24,9 @@ pub use event_emitter::EventEmitter;
 pub use feature_set_resolver::{FeatureSetResolverService, ResolutionSource, ResolvedFeatureSet};
 pub use grant_service::GrantService;
 pub use meta_tools::{
-    is_meta_tool, ApprovalBroker, ApprovalDecision, ApprovalPayload, ApprovalPublisher,
-    ApprovalRequest, ApprovalScope, MetaToolRegistry, MCPMUX_PREFIX,
+    is_meta_tool, routing_as_invoke_backend, ApprovalBroker, ApprovalDecision, ApprovalPayload,
+    ApprovalPublisher, ApprovalRequest, ApprovalScope, InvokeToolBackend, MetaToolRegistry,
+    MCPMUX_PREFIX,
 };
 pub use notification_emitter::NotificationEmitter;
 pub use prefix_cache::PrefixCacheService;