GREsau
commented
2 months ago Skimming through the OpenAI docs, it looks like this schema would define how a type is serialized rather than how it's deserialized, is that correct? If so, since the latest schemars alpha version (1.0.0-alpha.15), you can specify that you want the "serialize" schema by constructing a SchemaSettings and calling the for_serialize() method, e.g.:
let schema = SchemaSettings::default()
.for_serialize()
.into_generator()
.into_root_schema_for::<MyStruct>();Then, all fields will be included in the "required" array, even if they're Options. Of course, this assumes that none of the fields have #[serde(skip_serializing_if = ...)]/#[schemars(skip_serializing_if = ...)], because in that case it's possible for the field to not be included in the serialized output.
As for always setting "additionalProperties": false, you could either attach #[serde(deny_unknown_fields)] to all of your types, or alternatively you could write a custom Transform which forcibly sets that property on all schemas that define "properties". The easiest way to do this would be to define it as a fn(&mut Schema), and wrap it in RecursiveTransform to make it also apply to subschemas of the root schema e.g.:
RecursiveTransform(|schema: &mut Schema| {
if schema.get("properties").is_some() {
schema.insert("additionalProperties".to_owned(), false.into());
}
})I see there are some other restrictions on OpenAI structured output schemas, e.g. the docs don't mention the "const" or "oneOf" properties, so I assume those aren't supported either. Schemars has a built-in transform to replace "const" with a single-valued "enum" (ReplaceConstValue), and its easy enough to amend our custom transform above to also replace "oneOf" with "anyOf", which should behaves similarly enough for most cases.
None of the examples given in the OpenAI docs include a meta-schema ("$schema" property), so we can also clear the default meta_schema from our settings.
Putting it all together, we get:
let settings = SchemaSettings::default()
.for_serialize()
.with(|s| s.meta_schema = None)
.with_transform(ReplaceConstValue)
.with_transform(RecursiveTransform(|schema: &mut Schema| {
if schema.get("properties").is_some() {
schema.insert("additionalProperties".to_owned(), false.into());
}
if let Some(one_of) = schema.remove("oneOf") {
schema.insert("anyOf".to_owned(), one_of);
}
}));
let schema = settings.into_generator().into_root_schema_for::<MyStruct>();
println!("{}", serde_json::to_string_pretty(&schema).unwrap());For the example MyStruct/MyEnum types in the readme, this outputs the schema:
{
"title": "MyStruct",
"type": "object",
"properties": {
"my_bool": {
"type": "boolean"
},
"my_int": {
"type": "integer",
"format": "int32"
},
"my_nullable_enum": {
"anyOf": [
{
"$ref": "#/$defs/MyEnum"
},
{
"type": "null"
}
]
}
},
"additionalProperties": false,
"required": [
"my_int",
"my_bool",
"my_nullable_enum"
],
"$defs": {
"MyEnum": {
"anyOf": [
{
"type": "object",
"properties": {
"StringNewType": {
"type": "string"
}
},
"additionalProperties": false,
"required": [
"StringNewType"
]
},
{
"type": "object",
"properties": {
"StructVariant": {
"type": "object",
"properties": {
"floats": {
"type": "array",
"items": {
"type": "number",
"format": "float"
}
}
},
"additionalProperties": false,
"required": [
"floats"
]
}
},
"additionalProperties": false,
"required": [
"StructVariant"
]
}
]
}
}
}...which I think conforms to the OpenAI requirements
functorism
Some consumers of JSON Schema such as OpenAI Structured Output require that all fields are required. They also require that
"additionalProperties": falsealways be set (ensured by#[serde(deny_unknown_fields)]).The special
#[schemars(required)case forOption<T>makes it complicated to correctly express a schema which includes optional values (in the sense we want null as output). If this special case was opt-in, or there was an opt-out this friction would go away.