luminarys_sdk/
lib.rs

1//! Luminarys SDK for Rust skills.
2
3pub mod abi;
4pub mod archive;
5pub mod cluster;
6pub mod commands;
7pub mod context;
8pub mod entrypoint;
9pub mod fs;
10pub mod http;
11pub mod llm;
12pub mod shell;
13pub mod state;
14pub mod system;
15pub mod tcp;
16pub mod types;
17pub mod ws;
18
19pub use archive::*;
20pub use cluster::*;
21pub use commands::*;
22pub use context::Context;
23pub use entrypoint::*;
24pub use fs::*;
25pub use http::*;
26pub use llm::*;
27pub use shell::*;
28pub use state::*;
29pub use system::*;
30pub use tcp::*;
31pub use types::*;
32pub use ws::*;
33
34/// Serde helper: deserialise bytes from bin, null, or absent → empty Vec.
35pub(crate) mod bytes_or_null {
36    use serde::{Deserializer, Serializer};
37
38    pub fn serialize<S: Serializer>(v: &Vec<u8>, s: S) -> Result<S::Ok, S::Error> {
39        s.serialize_bytes(v)
40    }
41
42    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<u8>, D::Error> {
43        struct Visitor;
44        impl<'de> serde::de::Visitor<'de> for Visitor {
45            type Value = Vec<u8>;
46
47            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
48                write!(f, "byte array, null, or absent")
49            }
50            // msgpack bin format
51            fn visit_bytes<E: serde::de::Error>(self, v: &[u8]) -> Result<Vec<u8>, E> {
52                Ok(v.to_vec())
53            }
54            fn visit_byte_buf<E: serde::de::Error>(self, v: Vec<u8>) -> Result<Vec<u8>, E> {
55                Ok(v)
56            }
57            // msgpack array of u8 (rare but possible)
58            fn visit_seq<A: serde::de::SeqAccess<'de>>(
59                self, mut seq: A,
60            ) -> Result<Vec<u8>, A::Error> {
61                let mut v = Vec::new();
62                while let Some(b) = seq.next_element::<u8>()? {
63                    v.push(b);
64                }
65                Ok(v)
66            }
67            // msgpack nil → empty Vec
68            fn visit_unit<E: serde::de::Error>(self) -> Result<Vec<u8>, E> {
69                Ok(vec![])
70            }
71            fn visit_none<E: serde::de::Error>(self) -> Result<Vec<u8>, E> {
72                Ok(vec![])
73            }
74            fn visit_some<D2: Deserializer<'de>>(
75                self, d: D2,
76            ) -> Result<Vec<u8>, D2::Error> {
77                d.deserialize_any(self)
78            }
79        }
80        d.deserialize_any(Visitor)
81    }
82}
83
84/// Serde helper: deserialise int or float → i64.
85/// The host sometimes sends integer parameters as
86/// float64 (e.g. 3.0 instead of 3). This module accepts both forms.
87#[allow(dead_code)]
88pub(crate) mod int_or_float {
89    use serde::{Deserializer, Serializer};
90
91    pub fn serialize<S: Serializer>(v: &i64, s: S) -> Result<S::Ok, S::Error> {
92        s.serialize_i64(*v)
93    }
94
95    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<i64, D::Error> {
96        struct Visitor;
97        impl<'de> serde::de::Visitor<'de> for Visitor {
98            type Value = i64;
99            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
100                write!(f, "integer or float")
101            }
102            fn visit_i8<E: serde::de::Error>(self, v: i8)   -> Result<i64, E> { Ok(v as i64) }
103            fn visit_i16<E: serde::de::Error>(self, v: i16) -> Result<i64, E> { Ok(v as i64) }
104            fn visit_i32<E: serde::de::Error>(self, v: i32) -> Result<i64, E> { Ok(v as i64) }
105            fn visit_i64<E: serde::de::Error>(self, v: i64) -> Result<i64, E> { Ok(v) }
106            fn visit_u8<E: serde::de::Error>(self, v: u8)   -> Result<i64, E> { Ok(v as i64) }
107            fn visit_u16<E: serde::de::Error>(self, v: u16) -> Result<i64, E> { Ok(v as i64) }
108            fn visit_u32<E: serde::de::Error>(self, v: u32) -> Result<i64, E> { Ok(v as i64) }
109            fn visit_u64<E: serde::de::Error>(self, v: u64) -> Result<i64, E> { Ok(v as i64) }
110            fn visit_f32<E: serde::de::Error>(self, v: f32) -> Result<i64, E> { Ok(v as i64) }
111            fn visit_f64<E: serde::de::Error>(self, v: f64) -> Result<i64, E> { Ok(v as i64) }
112        }
113        d.deserialize_any(Visitor)
114    }
115}
116
117
118/// Convenience re-export of the most-used items.
119pub mod prelude {
120    pub use crate::archive::*;
121    pub use crate::cluster::*;
122    pub use crate::commands::*;
123    pub use crate::context::Context;
124    pub use crate::entrypoint::*;
125    pub use crate::fs::*;
126    pub use crate::http::*;
127    pub use crate::llm::*;
128    pub use crate::shell::*;
129    pub use crate::state::*;
130    pub use crate::system::*;
131    pub use crate::tcp::*;
132    pub use crate::types::*;
133    pub use crate::ws::*;
134}
135
136/// Serde helper: deserialise int or float → Option<i64>.
137/// Used for optional integer parameters in generated skill handlers.
138#[allow(dead_code)]
139pub(crate) mod int_or_float_opt {
140    use serde::{Deserializer, Serializer};
141
142    pub fn serialize<S: Serializer>(v: &Option<i64>, s: S) -> Result<S::Ok, S::Error> {
143        match v {
144            Some(n) => s.serialize_i64(*n),
145            None => s.serialize_none(),
146        }
147    }
148
149    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Option<i64>, D::Error> {
150        struct Visitor;
151        impl<'de> serde::de::Visitor<'de> for Visitor {
152            type Value = Option<i64>;
153            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
154                write!(f, "integer, float, or null")
155            }
156            fn visit_i8<E: serde::de::Error>(self, v: i8)   -> Result<Option<i64>, E> { Ok(Some(v as i64)) }
157            fn visit_i16<E: serde::de::Error>(self, v: i16) -> Result<Option<i64>, E> { Ok(Some(v as i64)) }
158            fn visit_i32<E: serde::de::Error>(self, v: i32) -> Result<Option<i64>, E> { Ok(Some(v as i64)) }
159            fn visit_i64<E: serde::de::Error>(self, v: i64) -> Result<Option<i64>, E> { Ok(Some(v)) }
160            fn visit_u8<E: serde::de::Error>(self, v: u8)   -> Result<Option<i64>, E> { Ok(Some(v as i64)) }
161            fn visit_u16<E: serde::de::Error>(self, v: u16) -> Result<Option<i64>, E> { Ok(Some(v as i64)) }
162            fn visit_u32<E: serde::de::Error>(self, v: u32) -> Result<Option<i64>, E> { Ok(Some(v as i64)) }
163            fn visit_u64<E: serde::de::Error>(self, v: u64) -> Result<Option<i64>, E> { Ok(Some(v as i64)) }
164            fn visit_f32<E: serde::de::Error>(self, v: f32) -> Result<Option<i64>, E> { Ok(Some(v as i64)) }
165            fn visit_f64<E: serde::de::Error>(self, v: f64) -> Result<Option<i64>, E> { Ok(Some(v as i64)) }
166            fn visit_unit<E: serde::de::Error>(self)         -> Result<Option<i64>, E> { Ok(None) }
167            fn visit_none<E: serde::de::Error>(self)         -> Result<Option<i64>, E> { Ok(None) }
168            fn visit_some<D2: Deserializer<'de>>(self, d: D2) -> Result<Option<i64>, D2::Error> {
169                d.deserialize_any(Visitor)
170            }
171        }
172        d.deserialize_any(Visitor)
173    }
174}
175
176/// Serde helper: deserialise bool or int → Option<bool>.
177/// Some hosts send boolean params as 0/1 integers instead of true/false.
178#[allow(dead_code)]
179pub(crate) mod bool_or_int_opt {
180    use serde::{Deserializer, Serializer};
181
182    pub fn serialize<S: Serializer>(v: &Option<bool>, s: S) -> Result<S::Ok, S::Error> {
183        match v {
184            Some(b) => s.serialize_bool(*b),
185            None => s.serialize_none(),
186        }
187    }
188
189    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Option<bool>, D::Error> {
190        struct Visitor;
191        impl<'de> serde::de::Visitor<'de> for Visitor {
192            type Value = Option<bool>;
193            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
194                write!(f, "bool, int, or null")
195            }
196            fn visit_bool<E: serde::de::Error>(self, v: bool) -> Result<Option<bool>, E> { Ok(Some(v)) }
197            fn visit_i64<E: serde::de::Error>(self, v: i64)   -> Result<Option<bool>, E> { Ok(Some(v != 0)) }
198            fn visit_u64<E: serde::de::Error>(self, v: u64)   -> Result<Option<bool>, E> { Ok(Some(v != 0)) }
199            fn visit_f64<E: serde::de::Error>(self, v: f64)   -> Result<Option<bool>, E> { Ok(Some(v != 0.0)) }
200            fn visit_unit<E: serde::de::Error>(self)           -> Result<Option<bool>, E> { Ok(None) }
201            fn visit_none<E: serde::de::Error>(self)           -> Result<Option<bool>, E> { Ok(None) }
202            fn visit_some<D2: Deserializer<'de>>(self, d: D2)  -> Result<Option<bool>, D2::Error> {
203                d.deserialize_any(Visitor)
204            }
205        }
206        d.deserialize_any(Visitor)
207    }
208}
209
210/// Serde helper: deserialise array or null/absent → Vec<T>.
211/// The host may send nil instead of an empty array for fields like `matches`.
212pub(crate) mod vec_or_null {
213    use serde::{Deserialize, Deserializer, Serializer};
214
215    pub fn serialize<S, T>(v: &Vec<T>, s: S) -> Result<S::Ok, S::Error>
216    where S: Serializer, T: serde::Serialize {
217        use serde::ser::SerializeSeq;
218        let mut seq = s.serialize_seq(Some(v.len()))?;
219        for item in v { seq.serialize_element(item)?; }
220        seq.end()
221    }
222
223    pub fn deserialize<'de, D, T>(d: D) -> Result<Vec<T>, D::Error>
224    where D: Deserializer<'de>, T: Deserialize<'de> {
225        struct Visitor<T>(std::marker::PhantomData<T>);
226        impl<'de, T: Deserialize<'de>> serde::de::Visitor<'de> for Visitor<T> {
227            type Value = Vec<T>;
228            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
229                write!(f, "array or null")
230            }
231            fn visit_seq<A: serde::de::SeqAccess<'de>>(self, mut seq: A) -> Result<Vec<T>, A::Error> {
232                let mut v = Vec::new();
233                while let Some(item) = seq.next_element()? { v.push(item); }
234                Ok(v)
235            }
236            fn visit_unit<E: serde::de::Error>(self) -> Result<Vec<T>, E> { Ok(vec![]) }
237            fn visit_none<E: serde::de::Error>(self) -> Result<Vec<T>, E> { Ok(vec![]) }
238            fn visit_some<D2: Deserializer<'de>>(self, d: D2) -> Result<Vec<T>, D2::Error> {
239                d.deserialize_any(self)
240            }
241        }
242        d.deserialize_any(Visitor(std::marker::PhantomData))
243    }
244}
luminarys_sdk/lib.rs

luminarys_sdk/
lib.rs
