nanocodex 0.1.0

A small, high-performance, headless Rust agents SDK
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
104
105
106
107
108
109
110
111
112
113
114
115
116

use tower::{
    ServiceBuilder,
    layer::util::{Identity, Stack},
};

/// Marker used until the standard Responses service is constructed by the
/// agent builder.
#[derive(Clone, Copy, Debug, Default)]
pub struct StandardResponses;

/// Deferred Tower layers applied to the standard Responses service when the
/// agent is built.
#[doc(hidden)]
pub struct LayeredResponses<L>(pub(crate) ServiceBuilder<L>);

/// Deferred caller service factory used to create one independent stack per
/// conversation branch.
#[doc(hidden)]
pub struct FactoryResponses<F>(pub(crate) F);

/// Responses transport configuration with standard or caller-supplied Tower
/// service factory policy.
pub struct Responses<S = StandardResponses> {
    pub(crate) websocket_url: Option<String>,
    pub(crate) api_base_url: Option<String>,
    pub(crate) service: S,
}

impl Default for Responses<StandardResponses> {
    fn default() -> Self {
        Self {
            websocket_url: None,
            api_base_url: None,
            service: StandardResponses,
        }
    }
}

impl Responses<StandardResponses> {
    #[must_use]
    pub fn builder() -> ResponsesBuilder<StandardResponses> {
        ResponsesBuilder {
            responses: Self::default(),
        }
    }
}

impl ResponsesBuilder<StandardResponses> {
    /// Adds a Tower layer around the SDK's standard persistent WebSocket and
    /// retry service. Layers are not materialized until
    /// [`crate::NanocodexBuilder::build`].
    #[must_use]
    pub fn layer<L>(self, layer: L) -> ResponsesBuilder<LayeredResponses<Stack<L, Identity>>> {
        ResponsesBuilder {
            responses: Responses {
                websocket_url: self.responses.websocket_url,
                api_base_url: self.responses.api_base_url,
                service: LayeredResponses(ServiceBuilder::new().layer(layer)),
            },
        }
    }

    /// Replaces the standard stack with a factory that constructs one fresh
    /// caller-composed service for the root and every child or fork.
    #[must_use]
    pub fn service<F, S>(self, factory: F) -> ResponsesBuilder<FactoryResponses<F>>
    where
        F: Fn() -> S,
    {
        ResponsesBuilder {
            responses: Responses {
                websocket_url: self.responses.websocket_url,
                api_base_url: self.responses.api_base_url,
                service: FactoryResponses(factory),
            },
        }
    }
}

impl<L> ResponsesBuilder<LayeredResponses<L>> {
    /// Adds another Tower layer to the deferred standard service stack.
    #[must_use]
    pub fn layer<T>(self, layer: T) -> ResponsesBuilder<LayeredResponses<Stack<T, L>>> {
        ResponsesBuilder {
            responses: Responses {
                websocket_url: self.responses.websocket_url,
                api_base_url: self.responses.api_base_url,
                service: LayeredResponses(self.responses.service.0.layer(layer)),
            },
        }
    }
}

/// Builder for the standard Responses endpoints or a caller-composed service.
pub struct ResponsesBuilder<S> {
    responses: Responses<S>,
}

impl<S> ResponsesBuilder<S> {
    #[must_use]
    pub fn websocket_url(mut self, url: impl Into<String>) -> Self {
        self.responses.websocket_url = Some(url.into());
        self
    }

    #[must_use]
    pub fn api_base_url(mut self, url: impl Into<String>) -> Self {
        self.responses.api_base_url = Some(url.into());
        self
    }

    #[must_use]
    pub fn build(self) -> Responses<S> {
        self.responses
    }
}