systemprompt-models 0.1.18

Shared data models and types for systemprompt.io OS
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
85
86
87
88
89
90
91

use serde::{Deserialize, Serialize};
use serde_json::Value as JsonValue;

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ResponseFormat {
    #[serde(rename = "text")]
    #[default]
    Text,

    #[serde(rename = "json_object")]
    JsonObject,

    #[serde(rename = "json_schema")]
    JsonSchema {
        schema: JsonValue,
        name: Option<String>,
        strict: Option<bool>,
    },
}

impl ResponseFormat {
    pub const fn json_object() -> Self {
        Self::JsonObject
    }

    pub const fn json_schema(schema: JsonValue) -> Self {
        Self::JsonSchema {
            schema,
            name: None,
            strict: Some(true),
        }
    }

    pub const fn json_schema_named(schema: JsonValue, name: String) -> Self {
        Self::JsonSchema {
            schema,
            name: Some(name),
            strict: Some(true),
        }
    }

    pub const fn is_json(&self) -> bool {
        !matches!(self, Self::Text)
    }

    pub const fn schema(&self) -> Option<&JsonValue> {
        match self {
            Self::JsonSchema { schema, .. } => Some(schema),
            Self::Text | Self::JsonObject => None,
        }
    }
}

#[derive(Debug, Clone, Default, Serialize, Deserialize)]
pub struct StructuredOutputOptions {
    pub response_format: Option<ResponseFormat>,
    pub max_retries: Option<u8>,
    pub inject_json_prompt: Option<bool>,
    pub extraction_pattern: Option<String>,
    pub validate_schema: Option<bool>,
}

impl StructuredOutputOptions {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn with_json_object() -> Self {
        Self {
            response_format: Some(ResponseFormat::JsonObject),
            inject_json_prompt: Some(true),
            validate_schema: Some(false),
            ..Default::default()
        }
    }

    pub fn with_schema(schema: JsonValue) -> Self {
        Self {
            response_format: Some(ResponseFormat::JsonSchema {
                schema,
                name: None,
                strict: Some(true),
            }),
            inject_json_prompt: Some(true),
            validate_schema: Some(true),
            max_retries: Some(3),
            ..Default::default()
        }
    }
}