Merge pull request #447 from apollographql/AIR-49

Fix compatibility issue with VSCode/Copilot

Author: DaleSeo

.changesets/fix_vscode_compatibility.md

@@ -0,0 +1,3 @@
+### Fix compatibility issue with VSCode/Copilot - @DaleSeo PR #447
+
+This updates Apollo MCP Server’s tool schemas from [Draft 2020-12](https://json-schema.org/draft/2020-12) to [Draft‑07](https://json-schema.org/draft-07) which is more widely supported across different validators. VSCode/Copilot still validate against Draft‑07, so rejects Apollo MCP Server’s tools. Our JSON schemas don’t rely on newer features, so downgrading improves compatibility across MCP clients with no practical impact.

crates/apollo-mcp-server/src/introspection/tools/introspect.rs

@@ -90,8 +90,10 @@ impl Introspect {
                         && schema
                             .root_operation(OperationType::Mutation)
                             .is_none_or(|root_name| {
+                                // Allow introspection of the mutation type itself even when mutations are disabled
                                 extended_type.name() != root_name
-                                    || (type_name == root_name.as_str() && self.allow_mutations)
+                                    || type_name == root_name.as_str()
+                                    || self.allow_mutations
                             })
                         && schema
                             .root_operation(OperationType::Subscription)
@@ -188,4 +190,131 @@ mod tests {
         assert!(description.contains("T=type,I=input,E=enum,U=union,F=interface"));
         assert!(description.contains("s=String,i=Int,f=Float,b=Boolean,d=ID"));
     }
+
+    #[rstest]
+    #[tokio::test]
+    async fn test_introspect_query_depth_1_returns_fields(schema: Valid<Schema>) {
+        let introspect = Introspect::new(
+            Arc::new(Mutex::new(schema)),
+            Some("Query".to_string()),
+            Some("Mutation".to_string()),
+            false,
+        );
+
+        let result = introspect
+            .execute(Input {
+                type_name: "Query".to_string(),
+                depth: 1,
+            })
+            .await
+            .expect("Introspect execution failed");
+
+        let content = result
+            .content
+            .iter()
+            .filter_map(|c| {
+                use rmcp::model::RawContent;
+                use std::ops::Deref;
+                let c = c.deref();
+                match c {
+                    RawContent::Text(text) => Some(text.text.clone()),
+                    _ => None,
+                }
+            })
+            .collect::<Vec<String>>()
+            .join("\n");
+
+        // Query with depth 1 should return the Query type with its fields
+        assert!(!result.content.is_empty());
+        assert!(content.contains("type Query"));
+    }
+
+    #[rstest]
+    #[tokio::test]
+    async fn test_introspect_mutation_depth_1_returns_fields(schema: Valid<Schema>) {
+        let introspect = Introspect::new(
+            Arc::new(Mutex::new(schema)),
+            Some("Query".to_string()),
+            Some("Mutation".to_string()),
+            false,
+        );
+
+        let result = introspect
+            .execute(Input {
+                type_name: "Mutation".to_string(),
+                depth: 1,
+            })
+            .await
+            .expect("Introspect execution failed");
+
+        let content = result
+            .content
+            .iter()
+            .filter_map(|c| {
+                use rmcp::model::RawContent;
+                use std::ops::Deref;
+                let c = c.deref();
+                match c {
+                    RawContent::Text(text) => Some(text.text.clone()),
+                    _ => None,
+                }
+            })
+            .collect::<Vec<String>>()
+            .join("\n");
+
+        // Mutation with depth 1 should return the Mutation type with its fields, just like Query
+        assert!(
+            !result.content.is_empty(),
+            "Mutation introspection should return content"
+        );
+        assert!(
+            content.contains("type Mutation"),
+            "Should contain Mutation type definition"
+        );
+    }
+
+    #[rstest]
+    #[tokio::test]
+    async fn test_introspect_mutation_depth_1_with_mutations_disabled(schema: Valid<Schema>) {
+        // This test verifies the fix: when mutations are not allowed, mutation introspection should still work
+        let introspect = Introspect::new(
+            Arc::new(Mutex::new(schema)),
+            Some("Query".to_string()),
+            None,
+            false,
+        );
+
+        let result = introspect
+            .execute(Input {
+                type_name: "Mutation".to_string(),
+                depth: 1,
+            })
+            .await
+            .expect("Introspect execution failed");
+
+        let content = result
+            .content
+            .iter()
+            .filter_map(|c| {
+                use rmcp::model::RawContent;
+                use std::ops::Deref;
+                let c = c.deref();
+                match c {
+                    RawContent::Text(text) => Some(text.text.clone()),
+                    _ => None,
+                }
+            })
+            .collect::<Vec<String>>()
+            .join("\n");
+
+        // After the fix: mutation introspection should work even when mutations are disabled
+        assert!(
+            !result.content.is_empty(),
+            "Mutation introspection should return content even when mutations are disabled"
+        );
+        assert!(
+            content.contains("type Mutation"),
+            "Should contain Mutation type definition"
+        );
+    }
 }

crates/apollo-mcp-server/src/introspection/tools/validate.rs

@@ -11,7 +11,6 @@ use rmcp::schemars::JsonSchema;
 use rmcp::serde_json::Value;
 use rmcp::{schemars, serde_json};
 use serde::Deserialize;
-use std::default::Default;
 use std::sync::Arc;
 use tokio::sync::Mutex;
 

crates/apollo-mcp-server/src/json_schema.rs

@@ -2,9 +2,47 @@
 #[macro_export]
 macro_rules! schema_from_type {
     ($type:ty) => {{
-        match serde_json::to_value(schemars::schema_for!($type)) {
+        // Use Draft-07 for compatibility with MCP clients like VSCode/Copilot that don't support newer drafts.
+        // See: https://github.com/microsoft/vscode/issues/251315
+        let settings = schemars::generate::SchemaSettings::draft07();
+        let generator = settings.into_generator();
+        let schema = generator.into_root_schema_for::<$type>();
+        match serde_json::to_value(schema) {
             Ok(Value::Object(schema)) => schema,
             _ => panic!("Failed to generate schema for {}", stringify!($type)),
         }
     }};
 }
+
+#[cfg(test)]
+mod tests {
+    use schemars::JsonSchema;
+    use serde::Deserialize;
+    use serde_json::Value;
+
+    #[derive(JsonSchema, Deserialize)]
+    struct TestInput {
+        #[allow(dead_code)]
+        field: String,
+    }
+
+    #[test]
+    fn test_schema_from_type() {
+        let schema = schema_from_type!(TestInput);
+
+        assert_eq!(
+            serde_json::to_value(&schema).unwrap(),
+            serde_json::json!({
+                "$schema": "http://json-schema.org/draft-07/schema#",
+                "title": "TestInput",
+                "type": "object",
+                "properties": {
+                    "field": {
+                        "type": "string"
+                    }
+                },
+                "required": ["field"]
+            })
+        );
+    }
+}