systemprompt-extension 0.1.19

Extension framework for systemprompt.io - register custom modules, providers, and APIs
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
94
95
96
97
98
99
100
101
102
103

use std::marker::PhantomData;

#[cfg(feature = "web")]
use crate::any::ApiExtensionWrapper;
use crate::any::{AnyExtension, ExtensionWrapper, SchemaExtensionWrapper};
use crate::error::LoaderError;
use crate::hlist::{Subset, TypeList};
#[cfg(feature = "web")]
use crate::typed::ApiExtensionTypedDyn;
use crate::typed::SchemaExtensionTyped;
use crate::typed_registry::TypedExtensionRegistry;
use crate::types::{Dependencies, ExtensionType};

pub struct ExtensionBuilder<Registered: TypeList = ()> {
    extensions: Vec<Box<dyn AnyExtension>>,
    _marker: PhantomData<Registered>,
}

impl<R: TypeList> std::fmt::Debug for ExtensionBuilder<R> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("ExtensionBuilder")
            .field("extension_count", &self.extensions.len())
            .finish_non_exhaustive()
    }
}

impl ExtensionBuilder<()> {
    #[must_use]
    pub fn new() -> Self {
        Self {
            extensions: Vec::new(),
            _marker: PhantomData,
        }
    }
}

impl Default for ExtensionBuilder<()> {
    fn default() -> Self {
        Self::new()
    }
}

impl<R: TypeList> ExtensionBuilder<R> {
    pub fn extension<E>(mut self, ext: E) -> ExtensionBuilder<(E, R)>
    where
        E: ExtensionType + Dependencies + std::fmt::Debug + 'static,
        E::Deps: Subset<R>,
    {
        self.extensions.push(Box::new(ExtensionWrapper::new(ext)));
        ExtensionBuilder {
            extensions: self.extensions,
            _marker: PhantomData,
        }
    }

    pub fn schema_extension<E>(mut self, ext: E) -> ExtensionBuilder<(E, R)>
    where
        E: ExtensionType + Dependencies + SchemaExtensionTyped + std::fmt::Debug + 'static,
        E::Deps: Subset<R>,
    {
        self.extensions
            .push(Box::new(SchemaExtensionWrapper::new(ext)));
        ExtensionBuilder {
            extensions: self.extensions,
            _marker: PhantomData,
        }
    }

    #[cfg(feature = "web")]
    pub fn api_extension<E>(mut self, ext: E) -> ExtensionBuilder<(E, R)>
    where
        E: ExtensionType + Dependencies + ApiExtensionTypedDyn + std::fmt::Debug + 'static,
        E::Deps: Subset<R>,
    {
        self.extensions
            .push(Box::new(ApiExtensionWrapper::new(ext)));
        ExtensionBuilder {
            extensions: self.extensions,
            _marker: PhantomData,
        }
    }

    pub fn build(self) -> Result<TypedExtensionRegistry, LoaderError> {
        let mut registry = TypedExtensionRegistry::new();
        let mut sorted = self.extensions;
        sorted.sort_by_key(|e| e.priority());

        for ext in sorted {
            if registry.has(ext.id()) {
                return Err(LoaderError::DuplicateExtension(ext.id().to_string()));
            }

            #[cfg(feature = "web")]
            if let Some(api) = ext.as_api() {
                registry.validate_api_path(ext.id(), api.base_path())?;
            }

            registry.add_boxed(ext);
        }

        Ok(registry)
    }
}