JSON schema for OpenAI and fault tolerant in parsing datetime.

Author: badmonster0

src/base/json_schema.rs

@@ -8,6 +8,9 @@ pub struct ToJsonSchemaOptions {
     /// Use union type (with `null`) for optional fields instead.
     /// Models like OpenAI will reject the schema if a field is not required.
     pub fields_always_required: bool,
+
+    /// If true, the JSON schema supports the `format` keyword.
+    pub supports_format: bool,
 }
 
 pub trait ToJsonSchema {
@@ -54,27 +57,46 @@ impl ToJsonSchema for schema::BasicValueType {
             }
             schema::BasicValueType::Uuid => {
                 schema.instance_type = Some(SingleOrVec::Single(Box::new(InstanceType::String)));
-                schema.format = Some("uuid".to_string());
+                if options.supports_format {
+                    schema.format = Some("uuid".to_string());
+                } else {
+                    schema.metadata.get_or_insert_default().description =
+                        Some("A UUID, e.g. 123e4567-e89b-12d3-a456-426614174000".to_string());
+                }
             }
             schema::BasicValueType::Date => {
                 schema.instance_type = Some(SingleOrVec::Single(Box::new(InstanceType::String)));
-                schema.format = Some("date".to_string());
+                if options.supports_format {
+                    schema.format = Some("date".to_string());
+                } else {
+                    schema.metadata.get_or_insert_default().description =
+                        Some("A date, e.g. 2025-03-27".to_string());
+                }
             }
             schema::BasicValueType::Time => {
                 schema.instance_type = Some(SingleOrVec::Single(Box::new(InstanceType::String)));
-                schema.format = Some("time".to_string());
+                if options.supports_format {
+                    schema.format = Some("time".to_string());
+                } else {
+                    schema.metadata.get_or_insert_default().description =
+                        Some("A time, e.g. 13:32:12".to_string());
+                }
             }
             schema::BasicValueType::LocalDateTime => {
                 schema.instance_type = Some(SingleOrVec::Single(Box::new(InstanceType::String)));
-                schema.format = Some("date-time".to_string());
+                if options.supports_format {
+                    schema.format = Some("date-time".to_string());
+                }
                 schema.metadata.get_or_insert_default().description =
-                    Some("Date time without timezone offset, YYYY-MM-DDThh:mm:ss".to_string());
+                    Some("Date time without timezone offset, e.g. 2025-03-27T13:32:12".to_string());
             }
             schema::BasicValueType::OffsetDateTime => {
                 schema.instance_type = Some(SingleOrVec::Single(Box::new(InstanceType::String)));
-                schema.format = Some("date-time".to_string());
+                if options.supports_format {
+                    schema.format = Some("date-time".to_string());
+                }
                 schema.metadata.get_or_insert_default().description =
-                    Some("Date time with timezone offset in RFC3339".to_string());
+                    Some("Date time with timezone offset in RFC3339, e.g. 2025-03-27T13:32:12Z, 2025-03-27T07:32:12.313-06:00".to_string());
             }
             schema::BasicValueType::Json => {
                 // Can be any value. No type constraint.

src/base/value.rs

@@ -1,14 +1,16 @@
 use crate::{api_bail, api_error};
 
 use super::schema::*;
-use anyhow::Result;
+use anyhow::{Context, Result};
 use base64::prelude::*;
+use chrono::Offset;
+use log::warn;
 use serde::{
     de::{SeqAccess, Visitor},
     ser::{SerializeMap, SerializeSeq, SerializeTuple},
     Deserialize, Serialize,
 };
-use std::{collections::BTreeMap, ops::Deref, sync::Arc};
+use std::{collections::BTreeMap, ops::Deref, str::FromStr, sync::Arc};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct RangeValue {
@@ -866,7 +868,20 @@ impl BasicValue {
                 BasicValue::LocalDateTime(v.parse()?)
             }
             (serde_json::Value::String(v), BasicValueType::OffsetDateTime) => {
-                BasicValue::OffsetDateTime(chrono::DateTime::parse_from_rfc3339(&v)?)
+                match chrono::DateTime::parse_from_rfc3339(&v) {
+                    Ok(dt) => BasicValue::OffsetDateTime(dt),
+                    Err(e) => {
+                        if let Ok(dt) = v.parse::<chrono::NaiveDateTime>() {
+                            warn!("Datetime without timezone offset, assuming UTC");
+                            BasicValue::OffsetDateTime(chrono::DateTime::from_naive_utc_and_offset(
+                                dt,
+                                chrono::Utc.fix(),
+                            ))
+                        } else {
+                            Err(e)?
+                        }
+                    }
+                }
             }
             (v, BasicValueType::Json) => BasicValue::Json(Arc::from(v)),
             (

src/llm/mod.rs

@@ -54,9 +54,15 @@ pub trait LlmGenerationClient: Send + Sync {
         false
     }
 
+    /// If true, the LLM supports the `format` keyword in the JSON schema.
+    fn json_schema_supports_format(&self) -> bool {
+        true
+    }
+
     fn to_json_schema_options(&self) -> ToJsonSchemaOptions {
         ToJsonSchemaOptions {
             fields_always_required: self.json_schema_fields_always_required(),
+            supports_format: self.json_schema_supports_format(),
         }
     }
 }

src/llm/openai.rs

@@ -101,4 +101,8 @@ impl LlmGenerationClient for Client {
     fn json_schema_fields_always_required(&self) -> bool {
         true
     }
+
+    fn json_schema_supports_format(&self) -> bool {
+        false
+    }
 }