agent-tk 0.4.0

`agent-tk` (`agent toolkit/tasks-knowledge`) is a crate for the development of autonomous agents using Rust, with an emphasis on tasks and knowledge based agents. This project is part of the [auKsys](http://auksys.org) project.
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
117
118
119
120
121
122
123
124
125
126

use agent_tk::delegation::Task;
use futures::FutureExt;
use std::{sync::Arc, time::Duration};
use yaaral::prelude::*;

mod consts
{
  pub const MQTT_NODE_ID: &str = "org.auksys.agent-tk.delegation-server";
  pub const MQTT_HOSTNAME: &str = "localhost";
  pub const MQTT_PORT: u16 = 1883;
}

#[derive(serde::Deserialize)]
struct StartDelegationRequest
{
  task_type: String,
  task_description: String,
}

#[derive(serde::Serialize)]
struct StartDelegationAnswer
{
  success: bool,
  message: String,
}

struct TaskExecutor {}

impl agent_tk::execution::default::TaskExecutor for TaskExecutor
{
  fn execute_task(
    &self,
    _: agent_tk::definitions::task::Task,
  ) -> futures::future::BoxFuture<'static, agent_tk::Result<()>>
  {
    async { Ok(()) }.boxed()
  }
  fn can_execute(&self, _: &agent_tk::definitions::task::Task) -> bool
  {
    false
  }
}

fn main()
{
  let runtime =
    agent_tk::Runtime::new(agent_tk::yaaral::Config::new().prefix("agent-tk-delegation-server"))
      .expect("a runtime");
  let (mqtt_channel_client, mqtt_task) = mqtt_channel::Client::build(
    format!("{}-services", consts::MQTT_NODE_ID),
    consts::MQTT_HOSTNAME,
    consts::MQTT_PORT,
  )
  .start();
  runtime.spawn_tokio_task(mqtt_task).unwrap().detach();
  let mqtt_client = mqtt_service::Client::new(mqtt_channel_client.clone());

  let agent = agent_tk::Agent::new::<
    agent_tk::delegation::mqtt::Module,
    agent_tk::decision::default::Module,
    agent_tk::execution::default::Module,
  >(
    agent_tk::agent::AgentData {
      agent_uri: "agent-tk-delegation-server".to_string(),
      async_runtime: runtime.to_owned(),
      knowledge_base: Box::new(agent_tk::knowledge_base::InMemoryBase::new()),
      states: agent_tk::states::States::default().into(),
      capabilities: agent_tk::definitions::agent::capabilities::Capabilities::default(),
      projection: agent_tk::projection::Projection::new(0.0, 0.0),
    },
    agent_tk::delegation::mqtt::Options::new(mqtt_channel_client),
    agent_tk::decision::default::Options::new(),
    agent_tk::execution::default::Options::new(TaskExecutor {}),
  )
  .expect("to have successfully created an agent");

  let agent = Arc::new(agent);
  let mruntime = runtime.clone();
  runtime
    .spawn_task(mqtt_client.create_json_async_service(
      mruntime,
      "delegation_server/delegate",
      move |request: StartDelegationRequest| {
        let agent = agent.clone();
        async move {
          let f = async || {
            let task = agent_tk::definitions::task::Task::from_description(
              &request.task_type,
              &request.task_description,
            )?;
            println!("delegate_task");
            let result = agent.delegate_task(task).await;
            println!("result: {:?}", result);
            let result = match result
            {
              Ok(_) => StartDelegationAnswer {
                success: true,
                message: Default::default(),
              },
              Err(e) => StartDelegationAnswer {
                success: false,
                message: e.to_string(),
              },
            };
            Ok::<StartDelegationAnswer, agent_tk::Error>(result)
          };
          match f().await
          {
            Ok(r) => r,
            Err(e) => StartDelegationAnswer {
              success: false,
              message: format!("Failed to call service: {}", e),
            },
          }
        }
      },
      10,
    ))
    .expect("Service to be started.")
    .detach();

  loop
  {
    std::thread::sleep(Duration::from_secs(60 * 60 * 24));
  }
}