amico-core 1.2.0

The core Agent components of the Amico AI Agent Framework
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

use std::{future::Future, time::Duration};

use amico_core::{
    Agent, OnFinish, ecs,
    traits::{EventSource, Strategy, System},
    types::{AgentEvent, Chat, Interaction},
};
use tokio::{task::JoinHandle, time::sleep};

#[cfg(feature = "wasm")]
use tokio_with_wasm::alias as tokio;

struct InteractionSource;

impl EventSource for InteractionSource {
    fn spawn<F, Fut>(&self, on_event: F) -> JoinHandle<anyhow::Result<()>>
    where
        F: Fn(AgentEvent) -> Fut + Send + Sync + 'static,
        Fut: Future<Output = Option<String>> + Send + 'static,
    {
        tokio::spawn(async move {
            for i in 1..10 {
                let event = AgentEvent::new("Chat", "InteractionSource")
                    .interaction(Chat::new().session_id(i).into_interaction());

                let result = on_event(event).await.unwrap();

                println!("Got reply: {}", result);

                // Simulate an asynchronous process.
                sleep(Duration::from_millis(30 + i * 5)).await;
            }

            Ok(())
        })
    }
}

struct InteractionStrategy;

impl Strategy for InteractionStrategy {
    async fn deliberate(
        &mut self,
        agent_event: &AgentEvent,
        mut sender: amico_core::world::ActionSender<'_>,
    ) -> anyhow::Result<Option<String>> {
        let interaction = agent_event.get_interaction().unwrap();

        match interaction {
            Interaction::Chat(chat) => {
                sender.send(Log(format!("Received chat interaction: {:?}", chat)));

                // Simulate an asynchronous reply generation process.
                sleep(Duration::from_millis(80)).await;
                Ok(Some(format!("Session ID: {}", chat.session_id)))
            } // _ => {}
        }
    }
}

struct LogSystem;

#[derive(amico_core::ecs::GlobalEvent)]
struct Log(String);

impl System for LogSystem {
    fn register_to(self, mut registry: amico_core::world::HandlerRegistry) {
        registry.register(|r: ecs::Receiver<Log>| {
            println!("log: {}", r.event.0);
        });
    }
}

#[tokio::test]
async fn test_agent() {
    // tracing_subscriber::fmt::init();

    let mut agent = Agent::new(InteractionStrategy);
    agent.spawn_event_source(InteractionSource, OnFinish::Stop);
    agent.add_system(LogSystem);

    agent.run().await;
}