revert: remove server-side empty parameter omission logic

This reverts commit b90c893.

The original implementation was incorrect as it made the server
second-guess client intent by omitting parameters that clients
explicitly provided. Empty values are valid and should be passed through
unchanged.

Root cause has been fixed at the client level in MCP Inspector PR:

modelcontextprotocol/inspector#772

Closes #65

Author: JMLX42

README.md

@@ -17,7 +17,6 @@ This enables AI assistants to interact with REST APIs through a standardized int
 - **Flexible Spec Loading**: Support for both URL-based and local file OpenAPI specifications
 - **HTTP Client Integration**: Built-in HTTP client with configurable base URLs and request handling
 - **Parameter Mapping**: Intelligent mapping of OpenAPI parameters (path, query, body) to MCP tool parameters
-- **Smart Parameter Handling**: Optional array parameters with empty values are automatically omitted from HTTP requests for OpenAPI compliance
 - **Output Schema Support**: Automatic generation of output schemas from OpenAPI response definitions
 - **Structured Content**: Returns parsed JSON responses as structured content when output schemas are defined
 - **Dual Usage Modes**: Use as a standalone MCP server or integrate as a Rust library
@@ -258,32 +257,6 @@ Example generated tools for Petstore API:
 - `updatePet`: Update an existing pet
 - `deletePet`: Delete a pet
 
-### Parameter Handling
-
-The server implements intelligent parameter handling to ensure OpenAPI specification compliance:
-
-#### Array Parameters
-- **Empty Optional Arrays**: Optional array parameters with empty values (`[]`) are automatically omitted from HTTP requests
-- **Non-Empty Optional Arrays**: Optional arrays with values are included normally
-- **Required Arrays**: Required array parameters are always processed, even when empty
-- **Arrays with Defaults**: Optional arrays with default values are always included, even when empty
-
-#### Examples
-```json
-// These parameters...
-{
-  "requiredTags": [],           // Required array - included as "?requiredTags="
-  "optionalTags": [],           // Optional array - omitted entirely  
-  "optionalWithDefault": [],    // Optional with default - included as "?optionalWithDefault="
-  "nonEmptyOptional": ["tag1"]  // Non-empty optional - included as "?nonEmptyOptional=tag1"
-}
-
-// ...generate this HTTP request:
-// GET /endpoint?requiredTags=&optionalWithDefault=&nonEmptyOptional=tag1
-```
-
-This behavior ensures that HTTP requests conform to OpenAPI specifications where optional parameters should be omitted when not needed, while preserving required parameters and those with explicit defaults.
-
 ### Output Schema Support
 
 The server now generates output schemas for all tools based on OpenAPI response definitions. This enables:

crates/rmcp-openapi/src/http_client.rs

@@ -132,7 +132,7 @@ impl HttpClient {
 
         // Add query parameters with proper URL encoding
         if !extracted_params.query.is_empty() {
-            Self::add_query_parameters(&mut url, &extracted_params.query, tool_metadata);
+            Self::add_query_parameters(&mut url, &extracted_params.query);
         }
 
         info!("Final URL: {}", url);
@@ -154,12 +154,12 @@ impl HttpClient {
 
         // Add request-specific headers (these override default headers)
         if !extracted_params.headers.is_empty() {
-            request = Self::add_headers(request, &extracted_params.headers, tool_metadata);
+            request = Self::add_headers(request, &extracted_params.headers);
         }
 
         // Add cookies
         if !extracted_params.cookies.is_empty() {
-            request = Self::add_cookies(request, &extracted_params.cookies, tool_metadata);
+            request = Self::add_cookies(request, &extracted_params.cookies);
         }
 
         // Add request body if present
@@ -369,24 +369,12 @@ impl HttpClient {
     }
 
     /// Add query parameters to the request using proper URL encoding
-    fn add_query_parameters(
-        url: &mut Url,
-        query_params: &HashMap<String, QueryParameter>,
-        tool_metadata: &ToolMetadata,
-    ) {
+    fn add_query_parameters(url: &mut Url, query_params: &HashMap<String, QueryParameter>) {
         {
             let mut query_pairs = url.query_pairs_mut();
             for (key, query_param) in query_params {
-                // Skip empty optional array parameters
-                if tool_metadata.should_omit_empty_array_parameter(key, &query_param.value) {
-                    continue;
-                }
                 if let Value::Array(arr) = &query_param.value {
-                    if arr.is_empty() {
-                        // For empty arrays that should be included (required or with defaults),
-                        // add the parameter with an empty value
-                        query_pairs.append_pair(key, "");
-                    } else if query_param.explode {
+                    if query_param.explode {
                         // explode=true: Handle array parameters - add each value as a separate query parameter
                         for item in arr {
                             let item_str = match item {
@@ -437,13 +425,8 @@ impl HttpClient {
     fn add_headers(
         mut request: RequestBuilder,
         headers: &HashMap<String, Value>,
-        tool_metadata: &ToolMetadata,
     ) -> RequestBuilder {
         for (key, value) in headers {
-            // Skip empty optional array parameters
-            if tool_metadata.should_omit_empty_array_parameter(key, value) {
-                continue;
-            }
             let value_str = match value {
                 Value::String(s) => s.clone(),
                 Value::Number(n) => n.to_string(),
@@ -459,15 +442,10 @@ impl HttpClient {
     fn add_cookies(
         mut request: RequestBuilder,
         cookies: &HashMap<String, Value>,
-        tool_metadata: &ToolMetadata,
     ) -> RequestBuilder {
         if !cookies.is_empty() {
             let cookie_header = cookies
                 .iter()
-                .filter(|(key, value)| {
-                    // Skip empty optional array parameters
-                    !tool_metadata.should_omit_empty_array_parameter(key, value)
-                })
                 .map(|(key, value)| {
                     let value_str = match value {
                         Value::String(s) => s.clone(),
@@ -480,9 +458,7 @@ impl HttpClient {
                 .collect::<Vec<_>>()
                 .join("; ");
 
-            if !cookie_header.is_empty() {
-                request = request.header(header::COOKIE, cookie_header);
-            }
+            request = request.header(header::COOKIE, cookie_header);
         }
         request
     }
@@ -925,7 +901,7 @@ mod tests {
         };
 
         let mut url = client.build_url(&tool_metadata, &extracted_params).unwrap();
-        HttpClient::add_query_parameters(&mut url, &extracted_params.query, &tool_metadata);
+        HttpClient::add_query_parameters(&mut url, &extracted_params.query);
 
         let url_string = url.to_string();
 
@@ -973,7 +949,7 @@ mod tests {
         };
 
         let mut url = client.build_url(&tool_metadata, &extracted_params).unwrap();
-        HttpClient::add_query_parameters(&mut url, &extracted_params.query, &tool_metadata);
+        HttpClient::add_query_parameters(&mut url, &extracted_params.query);
 
         let url_string = url.to_string();
 
@@ -1093,11 +1069,7 @@ mod tests {
         let mut url_exploded = client
             .build_url(&tool_metadata, &extracted_params_exploded)
             .unwrap();
-        HttpClient::add_query_parameters(
-            &mut url_exploded,
-            &extracted_params_exploded.query,
-            &tool_metadata,
-        );
+        HttpClient::add_query_parameters(&mut url_exploded, &extracted_params_exploded.query);
         let url_exploded_string = url_exploded.to_string();
 
         // Test explode=false (should generate comma-separated values)
@@ -1122,7 +1094,6 @@ mod tests {
         HttpClient::add_query_parameters(
             &mut url_not_exploded,
             &extracted_params_not_exploded.query,
-            &tool_metadata,
         );
         let url_not_exploded_string = url_not_exploded.to_string();
 
@@ -1139,192 +1110,4 @@ mod tests {
         println!("Exploded URL: {url_exploded_string}");
         println!("Non-exploded URL: {url_not_exploded_string}");
     }
-
-    #[test]
-    fn test_omit_empty_optional_array_query_parameters() {
-        let base_url = Url::parse("https://api.example.com").unwrap();
-        let client = HttpClient::new().with_base_url(base_url).unwrap();
-
-        // Create tool metadata with optional and required array parameters
-        let tool_metadata = crate::ToolMetadata {
-            name: "test".to_string(),
-            title: None,
-            description: "test".to_string(),
-            parameters: json!({
-                "type": "object",
-                "properties": {
-                    "optional_array": {"type": "array", "items": {"type": "string"}},
-                    "required_array": {"type": "array", "items": {"type": "string"}},
-                    "optional_with_default": {
-                        "type": "array",
-                        "items": {"type": "string"},
-                        "default": ["default"]
-                    },
-                    "optional_string": {"type": "string"}
-                },
-                "required": ["required_array"]
-            }),
-            output_schema: None,
-            method: "GET".to_string(),
-            path: "/test".to_string(),
-        };
-
-        let mut query_params = HashMap::new();
-        query_params.insert(
-            "optional_array".to_string(),
-            QueryParameter::new(json!([]), true),
-        ); // Empty optional array - should be omitted
-        query_params.insert(
-            "required_array".to_string(),
-            QueryParameter::new(json!([]), true),
-        ); // Empty required array - should be included
-        query_params.insert(
-            "optional_with_default".to_string(),
-            QueryParameter::new(json!([]), true),
-        ); // Empty optional with default - should be included
-        query_params.insert(
-            "optional_string".to_string(),
-            QueryParameter::new(json!(""), true),
-        ); // Empty string - should be included (not array)
-
-        let extracted_params = ExtractedParameters {
-            path: HashMap::new(),
-            query: query_params,
-            headers: HashMap::new(),
-            cookies: HashMap::new(),
-            body: HashMap::new(),
-            config: crate::tool_generator::RequestConfig::default(),
-        };
-
-        let mut url = client.build_url(&tool_metadata, &extracted_params).unwrap();
-        HttpClient::add_query_parameters(&mut url, &extracted_params.query, &tool_metadata);
-
-        let url_string = url.to_string();
-        // Verify empty optional array is omitted
-        assert!(!url_string.contains("optional_array"));
-
-        // Verify empty required array is included
-        assert!(url_string.contains("required_array"));
-
-        // Verify empty optional with default is included
-        assert!(url_string.contains("optional_with_default"));
-
-        // Verify empty string is included (not an array)
-        assert!(url_string.contains("optional_string"));
-    }
-
-    #[test]
-    fn test_omit_empty_optional_array_headers() {
-        let tool_metadata = crate::ToolMetadata {
-            name: "test".to_string(),
-            title: None,
-            description: "test".to_string(),
-            parameters: json!({
-                "type": "object",
-                "properties": {
-                    "x-optional-array": {"type": "array", "items": {"type": "string"}},
-                    "x-required-array": {"type": "array", "items": {"type": "string"}},
-                    "x-optional-string": {"type": "string"}
-                },
-                "required": ["x-required-array"]
-            }),
-            output_schema: None,
-            method: "GET".to_string(),
-            path: "/test".to_string(),
-        };
-
-        let mut headers = HashMap::new();
-        headers.insert("x-optional-array".to_string(), json!([])); // Should be omitted
-        headers.insert("x-required-array".to_string(), json!([])); // Should be included
-        headers.insert("x-optional-string".to_string(), json!("value")); // Should be included
-
-        let request = HttpClient::new()
-            .client
-            .request(reqwest::Method::GET, "https://api.example.com");
-        let request = HttpClient::add_headers(request, &headers, &tool_metadata);
-
-        // We can't easily inspect the headers without sending the request,
-        // but we can verify the function doesn't panic and returns a valid RequestBuilder
-        assert!(request.build().is_ok());
-    }
-
-    #[test]
-    fn test_omit_empty_optional_array_cookies() {
-        let tool_metadata = crate::ToolMetadata {
-            name: "test".to_string(),
-            title: None,
-            description: "test".to_string(),
-            parameters: json!({
-                "type": "object",
-                "properties": {
-                    "optional_array_cookie": {"type": "array", "items": {"type": "string"}},
-                    "required_array_cookie": {"type": "array", "items": {"type": "string"}},
-                    "optional_string_cookie": {"type": "string"}
-                },
-                "required": ["required_array_cookie"]
-            }),
-            output_schema: None,
-            method: "GET".to_string(),
-            path: "/test".to_string(),
-        };
-
-        let mut cookies = HashMap::new();
-        cookies.insert("optional_array_cookie".to_string(), json!([])); // Should be omitted
-        cookies.insert("required_array_cookie".to_string(), json!([])); // Should be included
-        cookies.insert("optional_string_cookie".to_string(), json!("value")); // Should be included
-
-        let request = HttpClient::new()
-            .client
-            .request(reqwest::Method::GET, "https://api.example.com");
-        let request = HttpClient::add_cookies(request, &cookies, &tool_metadata);
-
-        // Verify the function doesn't panic and returns a valid RequestBuilder
-        assert!(request.build().is_ok());
-    }
-
-    #[test]
-    fn test_non_empty_optional_arrays_are_included() {
-        let base_url = Url::parse("https://api.example.com").unwrap();
-        let client = HttpClient::new().with_base_url(base_url).unwrap();
-
-        let tool_metadata = crate::ToolMetadata {
-            name: "test".to_string(),
-            title: None,
-            description: "test".to_string(),
-            parameters: json!({
-                "type": "object",
-                "properties": {
-                    "optional_array": {"type": "array", "items": {"type": "string"}}
-                },
-                "required": []
-            }),
-            output_schema: None,
-            method: "GET".to_string(),
-            path: "/test".to_string(),
-        };
-
-        let mut query_params = HashMap::new();
-        query_params.insert(
-            "optional_array".to_string(),
-            QueryParameter::new(json!(["value1", "value2"]), true),
-        ); // Non-empty optional array - should be included
-
-        let extracted_params = ExtractedParameters {
-            path: HashMap::new(),
-            query: query_params,
-            headers: HashMap::new(),
-            cookies: HashMap::new(),
-            body: HashMap::new(),
-            config: crate::tool_generator::RequestConfig::default(),
-        };
-
-        let mut url = client.build_url(&tool_metadata, &extracted_params).unwrap();
-        HttpClient::add_query_parameters(&mut url, &extracted_params.query, &tool_metadata);
-
-        let url_string = url.to_string();
-
-        // Verify non-empty optional array is included
-        assert!(url_string.contains("optional_array=value1"));
-        assert!(url_string.contains("optional_array=value2"));
-    }
 }