Skip to content

Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors

Rust

fix(openai): enforce additionalProperties on schemas + use max_completion_tokens for gpt-5

Pablo Winter13f4d48a3eea
diff --git a/crates/ai-memory-llm/src/openai.rs b/crates/ai-memory-llm/src/openai.rs
index fff230b0..d3bbb80a 100644
--- a/crates/ai-memory-llm/src/openai.rs
+++ b/crates/ai-memory-llm/src/openai.rs
@@ -92,6 +92,8 @@ struct OpenAiRequest<'a> {
#[serde(skip_serializing_if = "Option::is_none")]
max_tokens: Option<u32>,
#[serde(skip_serializing_if = "Option::is_none")]
+ max_completion_tokens: Option<u32>,
+ #[serde(skip_serializing_if = "Option::is_none")]
temperature: Option<f32>,
#[serde(skip_serializing_if = "Option::is_none")]
response_format: Option<OpenAiResponseFormat>,
@@ -158,8 +160,9 @@ impl LlmProvider for OpenAiProvider {
async fn complete_structured_raw(
&self,
request: ChatRequest,
- schema: serde_json::Value,
+ mut schema: serde_json::Value,
) -> LlmResult<serde_json::Value> {
+ enforce_strict_object_schemas(&mut schema);
let response_format = OpenAiResponseFormat::JsonSchema {
json_schema: OpenAiJsonSchema {
name: "Result".into(),
@@ -201,10 +204,17 @@ impl OpenAiProvider {
content: &m.content,
});
}
+ let (max_tokens, max_completion_tokens) =
+ if model_requires_max_completion_tokens(&self.model) {
+ (None, Some(request.max_tokens))
+ } else {
+ (Some(request.max_tokens), None)
+ };
OpenAiRequest {
model: &self.model,
messages,
- max_tokens: Some(request.max_tokens),
+ max_tokens,
+ max_completion_tokens,
temperature: request.temperature,
response_format,
}
@@ -250,9 +260,175 @@ impl OpenAiProvider {
}
}
+/// Recursively enforce `additionalProperties: false` on every object node of
+/// a JSON schema. Required by OpenAI Structured Outputs (`strict: true`):
+/// without this, the API rejects the request with
+/// `'additionalProperties' is required to be supplied and to be false`.
+///
+/// Callers can hand us schemas authored elsewhere (or generated by
+/// macros) that don't bother — this normalisation hides the constraint
+/// from the rest of the codebase.
+fn enforce_strict_object_schemas(value: &mut serde_json::Value) {
+ match value {
+ serde_json::Value::Object(map) => {
+ let is_object = map
+ .get("type")
+ .and_then(|t| t.as_str())
+ .is_some_and(|t| t == "object")
+ || map.contains_key("properties");
+ if is_object && !map.contains_key("additionalProperties") {
+ map.insert("additionalProperties".to_string(), serde_json::json!(false));
+ }
+ for (_, v) in map.iter_mut() {
+ enforce_strict_object_schemas(v);
+ }
+ }
+ serde_json::Value::Array(items) => {
+ for v in items {
+ enforce_strict_object_schemas(v);
+ }
+ }
+ _ => {}
+ }
+}
+
+/// Models that require `max_completion_tokens` instead of `max_tokens`.
+/// OpenAI introduced this rename starting with the reasoning-capable o1
+/// family and made it mandatory across the gpt-5 line. Sending the legacy
+/// `max_tokens` to these models returns a 400 with
+/// `Unsupported parameter: 'max_tokens'`.
+fn model_requires_max_completion_tokens(model: &str) -> bool {
+ let m = model.to_ascii_lowercase();
+ m.starts_with("gpt-5") || m.starts_with("o1") || m.starts_with("o3") || m.starts_with("o4")
+}
+
#[cfg(test)]
mod tests {
- use super::normalize_openai_base;
+ use super::{
+ OpenAiProvider, enforce_strict_object_schemas, model_requires_max_completion_tokens,
+ normalize_openai_base,
+ };
+ use crate::types::{ChatMessage, ChatRequest, Role};
+ use secrecy::SecretString;
+ use serde_json::json;
+
+ fn provider_for(model: &str) -> OpenAiProvider {
+ OpenAiProvider::new(SecretString::new("test-key".into()), model).unwrap()
+ }
+
+ fn chat_request() -> ChatRequest {
+ ChatRequest {
+ system: None,
+ messages: vec![ChatMessage {
+ role: Role::User,
+ content: "hi".to_string(),
+ }],
+ max_tokens: 256,
+ temperature: None,
+ }
+ }
+
+ #[test]
+ fn enforce_strict_injects_additional_properties_false_on_root() {
+ let mut schema = json!({
+ "type": "object",
+ "properties": { "summary": { "type": "string" } },
+ "required": ["summary"]
+ });
+ enforce_strict_object_schemas(&mut schema);
+ assert_eq!(schema["additionalProperties"], json!(false));
+ }
+
+ #[test]
+ fn enforce_strict_recurses_into_nested_objects() {
+ let mut schema = json!({
+ "type": "object",
+ "properties": {
+ "page": {
+ "type": "object",
+ "properties": { "title": { "type": "string" } }
+ },
+ "tags": {
+ "type": "array",
+ "items": {
+ "type": "object",
+ "properties": { "name": { "type": "string" } }
+ }
+ }
+ }
+ });
+ enforce_strict_object_schemas(&mut schema);
+ assert_eq!(schema["additionalProperties"], json!(false));
+ assert_eq!(
+ schema["properties"]["page"]["additionalProperties"],
+ json!(false)
+ );
+ assert_eq!(
+ schema["properties"]["tags"]["items"]["additionalProperties"],
+ json!(false)
+ );
+ }
+
+ #[test]
+ fn enforce_strict_preserves_existing_additional_properties() {
+ let mut schema = json!({
+ "type": "object",
+ "properties": { "anything": { "type": "string" } },
+ "additionalProperties": true
+ });
+ enforce_strict_object_schemas(&mut schema);
+ assert_eq!(
+ schema["additionalProperties"],
+ json!(true),
+ "caller-set value must not be overwritten"
+ );
+ }
+
+ #[test]
+ fn enforce_strict_ignores_non_object_nodes() {
+ let mut schema = json!({ "type": "string" });
+ enforce_strict_object_schemas(&mut schema);
+ assert!(schema.get("additionalProperties").is_none());
+ }
+
+ #[test]
+ fn model_requires_max_completion_tokens_matches_gpt5_and_o_series() {
+ assert!(model_requires_max_completion_tokens("gpt-5"));
+ assert!(model_requires_max_completion_tokens("gpt-5-mini"));
+ assert!(model_requires_max_completion_tokens("gpt-5.4-nano"));
+ assert!(model_requires_max_completion_tokens("GPT-5"));
+ assert!(model_requires_max_completion_tokens("o1-mini"));
+ assert!(model_requires_max_completion_tokens("o3"));
+ assert!(model_requires_max_completion_tokens("o4-mini"));
+ }
+
+ #[test]
+ fn model_requires_max_completion_tokens_passes_gpt4_through() {
+ assert!(!model_requires_max_completion_tokens("gpt-4o-mini"));
+ assert!(!model_requires_max_completion_tokens("gpt-4-turbo"));
+ assert!(!model_requires_max_completion_tokens("gpt-3.5-turbo"));
+ assert!(!model_requires_max_completion_tokens("claude-haiku-4-5"));
+ }
+
+ #[test]
+ fn build_request_uses_max_tokens_for_gpt4() {
+ let p = provider_for("gpt-4o-mini");
+ let req_input = chat_request();
+ let req = p.build_request(&req_input, None);
+ let json = serde_json::to_value(&req).unwrap();
+ assert_eq!(json["max_tokens"], json!(256));
+ assert!(json.get("max_completion_tokens").is_none());
+ }
+
+ #[test]
+ fn build_request_uses_max_completion_tokens_for_gpt5() {
+ let p = provider_for("gpt-5.4-nano");
+ let req_input = chat_request();
+ let req = p.build_request(&req_input, None);
+ let json = serde_json::to_value(&req).unwrap();
+ assert_eq!(json["max_completion_tokens"], json!(256));
+ assert!(json.get("max_tokens").is_none());
+ }
#[test]
fn normalize_openai_base_chat_completions() {