daimon 0.16.0

A Rust-native 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
84
85

//! Serializable task and result types for distributed execution.
//!
//! These types are defined in [`daimon_core::distributed`] and re-exported here.

pub use daimon_core::distributed::{AgentTask, TaskResult, TaskStatus};

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_task_creation() {
        let task = AgentTask::new("Hello, world!");
        assert!(task.task_id.starts_with("task-"));
        assert_eq!(task.input, "Hello, world!");
        assert!(task.run_id.is_none());
        assert!(task.metadata.is_empty());
    }

    #[test]
    fn test_task_with_run_id() {
        let task = AgentTask::new("test").with_run_id("run-42");
        assert_eq!(task.run_id.as_deref(), Some("run-42"));
    }

    #[test]
    fn test_task_with_metadata() {
        let task = AgentTask::new("test")
            .with_metadata("priority", serde_json::json!(1));
        assert_eq!(task.metadata["priority"], serde_json::json!(1));
    }

    #[test]
    fn test_task_unique_ids() {
        let a = AgentTask::new("a");
        let b = AgentTask::new("b");
        assert_ne!(a.task_id, b.task_id);
    }

    #[test]
    fn test_task_serialization() {
        let task = AgentTask::new("serialize me")
            .with_run_id("r1")
            .with_metadata("key", serde_json::json!("val"));

        let json = serde_json::to_string(&task).unwrap();
        let deser: AgentTask = serde_json::from_str(&json).unwrap();
        assert_eq!(deser.input, "serialize me");
        assert_eq!(deser.run_id.as_deref(), Some("r1"));
    }

    #[test]
    fn test_result_serialization() {
        let result = TaskResult {
            task_id: "t-1".into(),
            output: "done".into(),
            iterations: 3,
            cost: 0.001,
            error: None,
        };
        let json = serde_json::to_string(&result).unwrap();
        let deser: TaskResult = serde_json::from_str(&json).unwrap();
        assert_eq!(deser.task_id, "t-1");
        assert_eq!(deser.iterations, 3);
    }

    #[test]
    fn test_status_variants() {
        let pending = TaskStatus::Pending;
        let running = TaskStatus::Running;
        let completed = TaskStatus::Completed(TaskResult {
            task_id: "t".into(),
            output: "ok".into(),
            iterations: 1,
            cost: 0.0,
            error: None,
        });
        let failed = TaskStatus::Failed("boom".into());

        assert!(matches!(pending, TaskStatus::Pending));
        assert!(matches!(running, TaskStatus::Running));
        assert!(matches!(completed, TaskStatus::Completed(_)));
        assert!(matches!(failed, TaskStatus::Failed(_)));
    }
}