refactor: clean up SSE transport variant

AGENTS.md

@@ -36,6 +36,30 @@ cargo doc --no-deps
 cargo llvm-cov --all-features --workspace --codecov --output-path codecov.json
 ```
 
+## Runtime Quick Reference
+
+- Start with config file: `cargo run -p apollo-mcp-server -- path/to/config.yaml`
+- Start from env only: `cargo run -p apollo-mcp-server`
+- Config precedence: `APOLLO_MCP_*` env overrides YAML values.
+- Supported transports: `stdio` (default) and `streamable_http`; `sse` is not supported.
+- YAML env expansion supports `${env.VAR}` and `${env.VAR:-default}`.
+
+### Common Config Keys
+
+- Top-level keys: `endpoint`, `transport`, `operations`, `schema`, `introspection`, `graphos`, `overrides`, `headers`, `forward_headers`, `health_check`, `cors`, `telemetry`, `logging`, `server_info`, `custom_scalars`.
+- `auth` must be nested under `transport` (not top-level).
+- `operations.source`: `infer` (default), `local`, `manifest`, `collection`, `introspect`, `uplink`.
+- `schema.source`: `local` or `uplink`.
+
+### Useful Env Vars
+
+- GraphOS mapping:
+  - `APOLLO_GRAPH_REF` -> `graphos.apollo_graph_ref`
+  - `APOLLO_KEY` -> `graphos.apollo_key`
+  - `APOLLO_UPLINK_ENDPOINTS` -> `graphos.apollo_uplink_endpoints`
+- Nested config override format: `APOLLO_MCP_<SECTION>__<NESTED_KEY>=...`
+  - Example: `APOLLO_MCP_INTROSPECTION__EXECUTE__ENABLED=true`
+
 ## Workspace Structure
 
 The project is a Rust workspace with three crates:

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

@@ -109,9 +109,6 @@ pub enum ServerError {
 
     #[error("TLS configuration error: {0}")]
     Tls(#[from] crate::auth::TlsConfigError),
-
-    #[error("Unsupported transport: {0}")]
-    UnsupportedTransport(String),
 }
 
 /// An MCP tool error

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

@@ -133,15 +133,16 @@ async fn main() -> anyhow::Result<()> {
         .disable_type_description(config.overrides.disable_type_description)
         .disable_schema_description(config.overrides.disable_schema_description)
         .enable_output_schema(config.overrides.enable_output_schema)
-        .disable_auth_token_passthrough(match transport {
-            apollo_mcp_server::server::Transport::Stdio => false,
-            apollo_mcp_server::server::Transport::SSE { auth, .. } => auth
-                .map(|a| a.disable_auth_token_passthrough)
-                .unwrap_or(false),
-            apollo_mcp_server::server::Transport::StreamableHttp { auth, .. } => auth
-                .map(|a| a.disable_auth_token_passthrough)
-                .unwrap_or(false),
-        })
+        .disable_auth_token_passthrough(
+            if let apollo_mcp_server::server::Transport::StreamableHttp {
+                auth: Some(auth), ..
+            } = &transport
+            {
+                auth.disable_auth_token_passthrough
+            } else {
+                false
+            },
+        )
         .custom_scalar_map(
             config
                 .custom_scalars

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

@@ -61,29 +61,11 @@ pub enum Transport {
     #[default]
     Stdio,
 
-    /// Host the MCP server on the supplied configuration, using SSE for communication
-    ///
-    /// Note: This is deprecated in favor of HTTP streams.
-    #[serde(rename = "sse")]
-    SSE {
-        /// Authentication configuration
-        #[serde(default)]
-        auth: Option<auth::Config>,
-
-        /// The IP address to bind to
-        #[serde(default = "Transport::default_address")]
-        address: IpAddr,
-
-        /// The port to bind to
-        #[serde(default = "Transport::default_port")]
-        port: u16,
-    },
-
     /// Host the MCP server on the configuration, using streamable HTTP messages.
     StreamableHttp {
         /// Authentication configuration
         #[serde(default)]
-        auth: Option<auth::Config>,
+        auth: Option<Box<auth::Config>>,
 
         /// The IP address to bind to
         #[serde(default = "Transport::default_address")]
@@ -191,3 +173,32 @@ impl Server {
         StateMachine {}.start(self).await
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::Transport;
+
+    #[test]
+    fn sse_transport_is_rejected_at_parse_time() {
+        let yaml = "type: sse\nport: 8000";
+        let result = serde_yaml::from_str::<Transport>(yaml);
+        assert!(result.is_err(), "Expected SSE transport to be rejected");
+    }
+
+    #[test]
+    fn stdio_transport_parses() {
+        let yaml = "type: stdio";
+        let result = serde_yaml::from_str::<Transport>(yaml);
+        assert!(result.is_ok(), "Expected stdio transport to parse");
+    }
+
+    #[test]
+    fn streamable_http_transport_parses() {
+        let yaml = "type: streamable_http\nport: 9000";
+        let result = serde_yaml::from_str::<Transport>(yaml);
+        assert!(
+            result.is_ok(),
+            "Expected streamable_http transport to parse"
+        );
+    }
+}

crates/apollo-mcp-server/src/server/states/starting.rs

@@ -138,12 +138,12 @@ impl Starting {
 
         let cancellation_token = CancellationToken::new();
 
-        // Create health check if enabled (only for StreamableHttp transport)
+        // Create health checks only when StreamableHttp transport is enabled.
         let health_check = match (&self.config.transport, self.config.health_check.enabled) {
             (Transport::StreamableHttp { .. }, true) => {
                 Some(HealthCheck::new(self.config.health_check.clone()))
             }
-            _ => None, // No health check for SSE, Stdio, or when disabled
+            _ => None, // No health checks for Stdio or when disabled.
         };
 
         let running = Running {
@@ -261,18 +261,6 @@ impl Starting {
                     }
                 });
             }
-            Transport::SSE {
-                auth: _,
-                address: _,
-                port: _,
-            } => {
-                // SSE transport has been removed in rmcp 0.11+
-                // Users should migrate to streamable_http transport
-                return Err(ServerError::UnsupportedTransport(
-                    "SSE transport is no longer supported. Please use streamable_http transport instead. \
-                     Update your config to use `transport: { type: streamable_http }`.".to_string()
-                ));
-            }
             Transport::Stdio => {
                 info!("Starting MCP server in stdio mode");
                 let service = running
@@ -348,53 +336,4 @@ mod tests {
         let running = starting.start();
         assert!(running.await.is_ok());
     }
-
-    #[tokio::test]
-    async fn start_sse_server_returns_unsupported_error() {
-        let starting = Starting {
-            config: Config {
-                transport: Transport::SSE {
-                    auth: None,
-                    address: "127.0.0.1".parse().unwrap(),
-                    port: 7798,
-                },
-                endpoint: Url::parse("http://localhost:4000").expect("valid url"),
-                mutation_mode: MutationMode::All,
-                execute_introspection: true,
-                headers: HeaderMap::new(),
-                forward_headers: vec![],
-                validate_introspection: true,
-                introspect_introspection: true,
-                search_introspection: true,
-                introspect_minify: false,
-                search_minify: false,
-                execute_tool_hint: None,
-                introspect_tool_hint: None,
-                search_tool_hint: None,
-                validate_tool_hint: None,
-                explorer_graph_ref: None,
-                custom_scalar_map: None,
-                disable_type_description: false,
-                disable_schema_description: false,
-                enable_output_schema: false,
-                disable_auth_token_passthrough: false,
-                search_leaf_depth: 5,
-                index_memory_bytes: 1024 * 1024 * 1024,
-                health_check: HealthCheckConfig::default(),
-                cors: Default::default(),
-                server_info: Default::default(),
-            },
-            schema: Schema::parse_and_validate("type Query { hello: String }", "test.graphql")
-                .expect("Valid schema"),
-            operations: vec![],
-        };
-        let result = starting.start().await;
-        match result {
-            Err(ServerError::UnsupportedTransport(msg)) => {
-                assert!(msg.contains("SSE transport is no longer supported"));
-            }
-            Err(e) => panic!("Expected UnsupportedTransport error, got: {:?}", e),
-            Ok(_) => panic!("Expected error, got Ok"),
-        }
-    }
 }

docs/source/config-file.mdx

@@ -227,6 +227,12 @@
 | `"stdio"`           | Use standard IO for communication between the server and client          |
 | `"streamable_http"` | Host the MCP server on the configuration, using streamable HTTP messages |
 
+<Note>
+
+SSE transport is no longer supported by Apollo MCP Server. Use `streamable_http` for HTTP-based connections.
+
+</Note>
+
 ##### Transport Type Specific options
 
 Some transport types support further configuration. For `streamable_http`, you can set `address`, `port`, `stateful_mode`, and `host_validation`.