askit_std_agents/
input.rs

1use std::vec;
2
3use agent_stream_kit::{
4    ASKit, Agent, AgentConfigs, AgentContext, AgentData, AgentError, AgentOutput, AgentStatus,
5    AgentValue, AsAgent, async_trait,
6};
7use askit_macros::askit_agent;
8
9static CATEGORY: &str = "Std/Input";
10
11static UNIT: &str = "unit";
12static BOOLEAN: &str = "boolean";
13static INTEGER: &str = "integer";
14static NUMBER: &str = "number";
15static STRING: &str = "string";
16static TEXT: &str = "text";
17static OBJECT: &str = "object";
18
19/// Unit Input
20#[askit_agent(
21    title = "Unit Input",
22    category = CATEGORY,
23    outputs = [UNIT],
24    unit_config(name = UNIT)
25)]
26struct UnitInputAgent {
27    data: AgentData,
28}
29
30impl AsAgent for UnitInputAgent {
31    fn new(
32        askit: ASKit,
33        id: String,
34        def_name: String,
35        configs: Option<AgentConfigs>,
36    ) -> Result<Self, AgentError> {
37        Ok(Self {
38            data: AgentData::new(askit, id, def_name, configs),
39        })
40    }
41
42    fn configs_changed(&mut self) -> Result<(), AgentError> {
43        // Since set_config is called even when the agent is not running,
44        // we need to check the status before outputting the value.
45        if *self.status() == AgentStatus::Start {
46            self.try_output(AgentContext::new(), UNIT, AgentValue::unit())?;
47        }
48
49        Ok(())
50    }
51}
52
53// Boolean Input
54#[askit_agent(
55    title = "Boolean Input",
56    category = CATEGORY,
57    inputs = [UNIT],
58    outputs = [BOOLEAN],
59    boolean_config(name = BOOLEAN),
60)]
61struct BooleanInputAgent {
62    data: AgentData,
63}
64
65#[async_trait]
66impl AsAgent for BooleanInputAgent {
67    fn new(
68        askit: ASKit,
69        id: String,
70        def_name: String,
71        configs: Option<AgentConfigs>,
72    ) -> Result<Self, AgentError> {
73        Ok(Self {
74            data: AgentData::new(askit, id, def_name, configs),
75        })
76    }
77
78    fn configs_changed(&mut self) -> Result<(), AgentError> {
79        if *self.status() == AgentStatus::Start {
80            let value = self.configs()?.get(BOOLEAN)?;
81            self.try_output(AgentContext::new(), BOOLEAN, value.clone())?;
82        }
83        Ok(())
84    }
85
86    async fn process(
87        &mut self,
88        ctx: AgentContext,
89        _pin: String,
90        _value: AgentValue,
91    ) -> Result<(), AgentError> {
92        let value = self.configs()?.get(BOOLEAN)?;
93        self.try_output(ctx, BOOLEAN, value.clone())
94    }
95}
96
97// Integer Input
98#[askit_agent(
99    title = "Integer Input",
100    category = CATEGORY,
101    inputs = [UNIT],
102    outputs = [INTEGER],
103    integer_config(name = INTEGER)
104)]
105struct IntegerInputAgent {
106    data: AgentData,
107}
108
109#[async_trait]
110impl AsAgent for IntegerInputAgent {
111    fn new(
112        askit: ASKit,
113        id: String,
114        def_name: String,
115        configs: Option<AgentConfigs>,
116    ) -> Result<Self, AgentError> {
117        Ok(Self {
118            data: AgentData::new(askit, id, def_name, configs),
119        })
120    }
121
122    fn configs_changed(&mut self) -> Result<(), AgentError> {
123        if *self.status() == AgentStatus::Start {
124            let value = self.configs()?.get(INTEGER)?;
125            self.try_output(AgentContext::new(), INTEGER, value.clone())?;
126        }
127        Ok(())
128    }
129
130    async fn process(
131        &mut self,
132        ctx: AgentContext,
133        _pin: String,
134        _value: AgentValue,
135    ) -> Result<(), AgentError> {
136        let value = self.configs()?.get(INTEGER)?;
137        self.try_output(ctx, INTEGER, value.clone())
138    }
139}
140
141// Number Input
142#[askit_agent(
143    title = "Number Input",
144    category = CATEGORY,
145    inputs = [UNIT],
146    outputs = [NUMBER],
147    number_config(name = NUMBER)
148)]
149struct NumberInputAgent {
150    data: AgentData,
151}
152
153#[async_trait]
154impl AsAgent for NumberInputAgent {
155    fn new(
156        askit: ASKit,
157        id: String,
158        def_name: String,
159        configs: Option<AgentConfigs>,
160    ) -> Result<Self, AgentError> {
161        Ok(Self {
162            data: AgentData::new(askit, id, def_name, configs),
163        })
164    }
165
166    fn configs_changed(&mut self) -> Result<(), AgentError> {
167        if *self.status() == AgentStatus::Start {
168            let value = self.configs()?.get(NUMBER)?;
169            self.try_output(AgentContext::new(), NUMBER, value.clone())?;
170        }
171        Ok(())
172    }
173
174    async fn process(
175        &mut self,
176        ctx: AgentContext,
177        _pin: String,
178        _value: AgentValue,
179    ) -> Result<(), AgentError> {
180        let value = self.configs()?.get(NUMBER)?;
181        self.try_output(ctx, NUMBER, value.clone())
182    }
183}
184
185// String Input
186#[askit_agent(
187    title = "String Input",
188    category = CATEGORY,
189    inputs = [UNIT],
190    outputs = [STRING],
191    string_config(name = STRING)
192)]
193struct StringInputAgent {
194    data: AgentData,
195}
196
197#[async_trait]
198impl AsAgent for StringInputAgent {
199    fn new(
200        askit: ASKit,
201        id: String,
202        def_name: String,
203        configs: Option<AgentConfigs>,
204    ) -> Result<Self, AgentError> {
205        Ok(Self {
206            data: AgentData::new(askit, id, def_name, configs),
207        })
208    }
209
210    fn configs_changed(&mut self) -> Result<(), AgentError> {
211        if *self.status() == AgentStatus::Start {
212            let value = self.configs()?.get(STRING)?;
213            self.try_output(AgentContext::new(), STRING, value.clone())?;
214        }
215        Ok(())
216    }
217
218    async fn process(
219        &mut self,
220        ctx: AgentContext,
221        _pin: String,
222        _value: AgentValue,
223    ) -> Result<(), AgentError> {
224        let value = self.configs()?.get(STRING)?;
225        self.try_output(ctx, STRING, value.clone())
226    }
227}
228
229// Text Input
230#[askit_agent(
231    title = "Text Input",
232    category = CATEGORY,
233    inputs = [UNIT],
234    outputs = [TEXT],
235    text_config(name = TEXT)
236)]
237struct TextInputAgent {
238    data: AgentData,
239}
240
241#[async_trait]
242impl AsAgent for TextInputAgent {
243    fn new(
244        askit: ASKit,
245        id: String,
246        def_name: String,
247        configs: Option<AgentConfigs>,
248    ) -> Result<Self, AgentError> {
249        Ok(Self {
250            data: AgentData::new(askit, id, def_name, configs),
251        })
252    }
253
254    fn configs_changed(&mut self) -> Result<(), AgentError> {
255        if *self.status() == AgentStatus::Start {
256            let value = self.configs()?.get(TEXT)?;
257            self.try_output(AgentContext::new(), TEXT, value.clone())?;
258        }
259        Ok(())
260    }
261
262    async fn process(
263        &mut self,
264        ctx: AgentContext,
265        _pin: String,
266        _value: AgentValue,
267    ) -> Result<(), AgentError> {
268        let value = self.configs()?.get(TEXT)?;
269        self.try_output(ctx, TEXT, value.clone())
270    }
271}
272
273// Object Input
274#[askit_agent(
275    title = "Object Input",
276    category = CATEGORY,
277    inputs = [UNIT],
278    outputs = [OBJECT],
279    object_config(name = OBJECT)
280)]
281struct ObjectInputAgent {
282    data: AgentData,
283}
284
285#[async_trait]
286impl AsAgent for ObjectInputAgent {
287    fn new(
288        askit: ASKit,
289        id: String,
290        def_name: String,
291        configs: Option<AgentConfigs>,
292    ) -> Result<Self, AgentError> {
293        Ok(Self {
294            data: AgentData::new(askit, id, def_name, configs),
295        })
296    }
297
298    fn configs_changed(&mut self) -> Result<(), AgentError> {
299        if *self.status() == AgentStatus::Start {
300            let value = self.configs()?.get(OBJECT)?;
301            self.try_output(AgentContext::new(), OBJECT, value.clone())?;
302        }
303        Ok(())
304    }
305
306    async fn process(
307        &mut self,
308        ctx: AgentContext,
309        _pin: String,
310        _value: AgentValue,
311    ) -> Result<(), AgentError> {
312        let value = self.configs()?.get(OBJECT)?;
313        self.try_output(ctx, OBJECT, value.clone())
314    }
315}
askit_std_agents/input.rs

askit_std_agents/
input.rs
