fix: accept logprobs as integer and warn on unsupported params instead of rejecting

- Add custom deserializer for chat completion logprobs field to accept
  both boolean and integer values (0=false, non-zero=true)
- Change unsupported field validation to log warnings instead of
  returning errors, improving compatibility with clients that send
  extra parameters like add_special_tokens, prompt_cache_key,
  request_id, and chat_template

https://claude.ai/code/session_01EoHsvxn4B3WMuJkwP5f6od

Author: claude

lib/async-openai/src/types/chat.rs

@@ -12,12 +12,39 @@ use std::{collections::HashMap, pin::Pin};
 
 use derive_builder::Builder;
 use futures::Stream;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use utoipa::ToSchema;
 
 use url::Url;
 use uuid::{Uuid, uuid};
 
+/// Custom deserializer that accepts both boolean and integer values for logprobs.
+/// Integer values are coerced to boolean (0 = false, non-zero = true).
+fn deserialize_bool_or_int<'de, D>(deserializer: D) -> Result<Option<bool>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let value: Option<serde_json::Value> = Option::deserialize(deserializer)?;
+    match value {
+        None => Ok(None),
+        Some(serde_json::Value::Bool(b)) => Ok(Some(b)),
+        Some(serde_json::Value::Number(n)) => {
+            if let Some(i) = n.as_i64() {
+                Ok(Some(i != 0))
+            } else if let Some(f) = n.as_f64() {
+                Ok(Some(f != 0.0))
+            } else {
+                Err(serde::de::Error::custom(
+                    "logprobs must be a boolean or integer",
+                ))
+            }
+        }
+        Some(_) => Err(serde::de::Error::custom(
+            "logprobs must be a boolean or integer",
+        )),
+    }
+}
+
 use crate::error::OpenAIError;
 
 #[derive(ToSchema, Debug, Serialize, Deserialize, Clone, PartialEq)]
@@ -949,7 +976,12 @@ pub struct CreateChatCompletionRequest {
     pub logit_bias: Option<HashMap<String, serde_json::Value>>, // default: null
 
     /// Whether to return log probabilities of the output tokens or not. If true, returns the log probabilities of each output token returned in the `content` of `message`.
-    #[serde(skip_serializing_if = "Option::is_none")]
+    /// Also accepts integer values for compatibility (0 = false, non-zero = true).
+    #[serde(
+        skip_serializing_if = "Option::is_none",
+        default,
+        deserialize_with = "deserialize_bool_or_int"
+    )]
     pub logprobs: Option<bool>,
 
     /// An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability. `logprobs` must be set to `true` if this parameter is used.

lib/llm/src/http/service/openai.rs

@@ -2786,17 +2786,9 @@ mod tests {
         assert!(request.unsupported_fields.contains_key("documents"));
         assert!(request.unsupported_fields.contains_key("chat_template"));
 
+        // Unsupported fields should now produce a warning but not an error
         let result = validate_chat_completion_fields_generic(&request);
-        assert!(result.is_err());
-        if let Err(error_response) = result {
-            assert_eq!(error_response.0, StatusCode::BAD_REQUEST);
-            let msg = &error_response.1.message;
-            assert!(msg.contains("Unsupported parameter"));
-            // Verify all fields appear in the error message
-            assert!(msg.contains("add_special_tokens"));
-            assert!(msg.contains("documents"));
-            assert!(msg.contains("chat_template"));
-        }
+        assert!(result.is_ok());
     }
 
     #[test]
@@ -2819,16 +2811,9 @@ mod tests {
         );
         assert!(request.unsupported_fields.contains_key("response_format"));
 
+        // Unsupported fields should now produce a warning but not an error
         let result = validate_completion_fields_generic(&request);
-        assert!(result.is_err());
-        if let Err(error_response) = result {
-            assert_eq!(error_response.0, StatusCode::BAD_REQUEST);
-            let msg = &error_response.1.message;
-            assert!(msg.contains("Unsupported parameter"));
-            // Verify both fields appear in error message
-            assert!(msg.contains("add_special_tokens"));
-            assert!(msg.contains("response_format"));
-        }
+        assert!(result.is_ok());
     }
 
     #[tokio::test]

lib/llm/src/protocols/openai/chat_completions.rs

@@ -426,4 +426,62 @@ mod tests {
             assert_eq!(output_options.skip_special_tokens, Some(skip_value));
         }
     }
+
+    #[test]
+    fn test_logprobs_accepts_integer() {
+        // logprobs: 1 (integer) should be treated as true
+        let json_str = json!({
+            "model": "test-model",
+            "messages": [{"role": "user", "content": "Hello"}],
+            "logprobs": 1
+        });
+        let request: NvCreateChatCompletionRequest =
+            serde_json::from_value(json_str).expect("Failed to deserialize request with logprobs integer");
+        assert_eq!(request.inner.logprobs, Some(true));
+
+        // logprobs: 0 should be treated as false
+        let json_str = json!({
+            "model": "test-model",
+            "messages": [{"role": "user", "content": "Hello"}],
+            "logprobs": 0
+        });
+        let request: NvCreateChatCompletionRequest =
+            serde_json::from_value(json_str).expect("Failed to deserialize request with logprobs 0");
+        assert_eq!(request.inner.logprobs, Some(false));
+
+        // logprobs: true should still work
+        let json_str = json!({
+            "model": "test-model",
+            "messages": [{"role": "user", "content": "Hello"}],
+            "logprobs": true
+        });
+        let request: NvCreateChatCompletionRequest =
+            serde_json::from_value(json_str).expect("Failed to deserialize request with logprobs bool");
+        assert_eq!(request.inner.logprobs, Some(true));
+    }
+
+    #[test]
+    fn test_unsupported_fields_warn_not_error() {
+        use crate::engines::ValidateRequest;
+
+        let json_str = json!({
+            "model": "test-model",
+            "messages": [{"role": "user", "content": "Hello"}],
+            "add_special_tokens": true,
+            "prompt_cache_key": "key123",
+            "request_id": "req-456",
+            "chat_template": "custom"
+        });
+        let request: NvCreateChatCompletionRequest =
+            serde_json::from_value(json_str).expect("Failed to deserialize request");
+
+        // These fields should be captured as unsupported
+        assert!(request.unsupported_fields.contains_key("add_special_tokens"));
+        assert!(request.unsupported_fields.contains_key("prompt_cache_key"));
+        assert!(request.unsupported_fields.contains_key("request_id"));
+        assert!(request.unsupported_fields.contains_key("chat_template"));
+
+        // Validation should succeed (warn, not error)
+        assert!(ValidateRequest::validate(&request).is_ok());
+    }
 }

lib/llm/src/protocols/openai/validate.rs

@@ -97,7 +97,11 @@ pub const MAX_REPETITION_PENALTY: f32 = 2.0;
 // Shared Fields
 //
 
-/// Validates that no unsupported fields are present in the request
+/// Validates unsupported fields in the request.
+/// Instead of rejecting requests with unsupported fields, this now logs a warning
+/// and allows the request to proceed. This improves compatibility with clients
+/// that send extra parameters (e.g. add_special_tokens, prompt_cache_key,
+/// request_id, chat_template).
 pub fn validate_no_unsupported_fields(
     unsupported_fields: &std::collections::HashMap<String, serde_json::Value>,
 ) -> Result<(), anyhow::Error> {
@@ -106,7 +110,7 @@ pub fn validate_no_unsupported_fields(
             .keys()
             .map(|s| format!("`{}`", s))
             .collect();
-        anyhow::bail!("Unsupported parameter(s): {}", fields.join(", "));
+        tracing::warn!("Ignoring unsupported parameter(s): {}", fields.join(", "));
     }
     Ok(())
 }