agentics-domain 0.4.0

Domain types and validation models for the Agentics challenge platform.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//! Serde helpers for source challenge contracts.

use schemars::{JsonSchema, Schema, SchemaGenerator, json_schema};
use serde::de::Error as DeError;
use serde::{Deserialize, Deserializer, Serialize, Serializer};

/// Deserialize a field that must be present but may be JSON null.
pub(crate) fn required_nullable<'de, T, D>(deserializer: D) -> Result<Option<T>, D::Error>
where
    T: Deserialize<'de>,
    D: Deserializer<'de>,
{
    Option::<T>::deserialize(deserializer)
}

/// Emit a schema for a field that must be present but may be JSON null.
pub(crate) fn required_nullable_schema<T>(generator: &mut SchemaGenerator) -> Schema
where
    T: JsonSchema,
{
    let value_schema = generator.subschema_for::<T>();
    json_schema!({
        "x-agentics-preserve-null": true,
        "oneOf": [
            { "type": "null" },
            value_schema
        ]
    })
}

/// Deserialize a required nullable vector where JSON null means no entries.
///
/// Empty arrays are rejected so authors use `null` for the semantic absence case
/// and a non-empty array only when entries are present.
pub(crate) fn required_nullable_non_empty_vec<'de, T, D>(
    deserializer: D,
) -> Result<Vec<T>, D::Error>
where
    T: Deserialize<'de>,
    D: Deserializer<'de>,
{
    match Option::<Vec<T>>::deserialize(deserializer)? {
        None => Ok(Vec::new()),
        Some(values) if values.is_empty() => Err(D::Error::custom(
            "must be null when absent or a non-empty array when present",
        )),
        Some(values) => Ok(values),
    }
}

/// Emit a schema for a required nullable vector where present arrays are non-empty.
pub(crate) fn required_nullable_non_empty_vec_schema<T>(generator: &mut SchemaGenerator) -> Schema
where
    T: JsonSchema,
{
    let item_schema = generator.subschema_for::<T>();
    json_schema!({
        "x-agentics-preserve-null": true,
        "oneOf": [
            { "type": "null" },
            {
                "type": "array",
                "minItems": 1,
                "items": item_schema
            }
        ]
    })
}

/// Serialize an empty vector as JSON null for required-nullable source fields.
pub(crate) fn serialize_empty_vec_as_null<T, S>(
    values: &[T],
    serializer: S,
) -> Result<S::Ok, S::Error>
where
    T: Serialize,
    S: Serializer,
{
    if values.is_empty() {
        serializer.serialize_none()
    } else {
        values.serialize(serializer)
    }
}