prompty 2.0.0-alpha.11

Prompty is an asset class and format for LLM prompts
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
92
93

// Code generated by AgentSchema emitter; DO NOT EDIT.

#![allow(
    unused_imports,
    dead_code,
    non_camel_case_types,
    unused_variables,
    clippy::all
)]

use super::super::context::{LoadContext, SaveContext};

use super::format_config::FormatConfig;

use super::parser_config::ParserConfig;

/// Template model for defining prompt templates. This model specifies the rendering engine used for slot filling prompts, the parser used to process the rendered template into API-compatible format, and additional options for the template engine. It allows for the creation of reusable templates that can be filled with dynamic data and processed to generate prompts for AI models.
#[derive(Debug, Clone, Default)]
pub struct Template {
    /// Template rendering engine used for slot filling prompts (e.g., mustache, jinja2)
    pub format: FormatConfig,
    /// Parser used to process the rendered template into API-compatible format
    pub parser: ParserConfig,
}

impl Template {
    /// Create a new Template with default values.
    pub fn new() -> Self {
        Self::default()
    }

    /// Load Template from a JSON string.
    pub fn from_json(json: &str, ctx: &LoadContext) -> Result<Self, serde_json::Error> {
        let value: serde_json::Value = serde_json::from_str(json)?;
        Ok(Self::load_from_value(&value, ctx))
    }

    /// Load Template from a YAML string.
    pub fn from_yaml(yaml: &str, ctx: &LoadContext) -> Result<Self, serde_yaml::Error> {
        let value: serde_json::Value = serde_yaml::from_str(yaml)?;
        Ok(Self::load_from_value(&value, ctx))
    }

    /// Load Template from a `serde_json::Value`.
    ///
    /// Calls `ctx.process_input` before field extraction.
    pub fn load_from_value(value: &serde_json::Value, ctx: &LoadContext) -> Self {
        let value = ctx.process_input(value.clone());
        Self {
            format: value
                .get("format")
                .filter(|v| v.is_object() || v.is_array() || v.is_string())
                .map(|v| FormatConfig::load_from_value(v, ctx))
                .unwrap_or_default(),
            parser: value
                .get("parser")
                .filter(|v| v.is_object() || v.is_array() || v.is_string())
                .map(|v| ParserConfig::load_from_value(v, ctx))
                .unwrap_or_default(),
        }
    }

    /// Serialize Template to a `serde_json::Value`.
    ///
    /// Calls `ctx.process_dict` after serialization.
    pub fn to_value(&self, ctx: &SaveContext) -> serde_json::Value {
        let mut result = serde_json::Map::new();
        // Write base fields
        {
            let nested = self.format.to_value(ctx);
            if !nested.is_null() {
                result.insert("format".to_string(), nested);
            }
        }
        {
            let nested = self.parser.to_value(ctx);
            if !nested.is_null() {
                result.insert("parser".to_string(), nested);
            }
        }
        ctx.process_dict(serde_json::Value::Object(result))
    }

    /// Serialize Template to a JSON string.
    pub fn to_json(&self, ctx: &SaveContext) -> Result<String, serde_json::Error> {
        serde_json::to_string_pretty(&self.to_value(ctx))
    }

    /// Serialize Template to a YAML string.
    pub fn to_yaml(&self, ctx: &SaveContext) -> Result<String, serde_yaml::Error> {
        serde_yaml::to_string(&self.to_value(ctx))
    }
}