lago-core 0.2.1

Foundation types, traits, and error definitions for the Lago agent runtime
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

use crate::event::SpanStatus;
use serde::{Deserialize, Serialize};

/// Represents a tool execution span (invoke -> result).
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ToolSpan {
    pub call_id: String,
    pub tool_name: String,
    pub arguments: serde_json::Value,
    pub category: Option<String>,
    pub status: Option<SpanStatus>,
    pub result: Option<serde_json::Value>,
    pub started_at: u64,
    pub ended_at: Option<u64>,
    pub duration_ms: Option<u64>,
}

impl ToolSpan {
    pub fn new(call_id: String, tool_name: String, arguments: serde_json::Value) -> Self {
        Self {
            call_id,
            tool_name,
            arguments,
            category: None,
            status: None,
            result: None,
            started_at: crate::event::EventEnvelope::now_micros(),
            ended_at: None,
            duration_ms: None,
        }
    }

    pub fn is_complete(&self) -> bool {
        self.status.is_some()
    }
}

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

    #[test]
    fn new_span_is_incomplete() {
        let span = ToolSpan::new(
            "call-1".into(),
            "read_file".into(),
            serde_json::json!({"path": "/foo"}),
        );
        assert!(!span.is_complete());
        assert_eq!(span.call_id, "call-1");
        assert_eq!(span.tool_name, "read_file");
        assert!(span.started_at > 0);
        assert!(span.ended_at.is_none());
        assert!(span.result.is_none());
        assert!(span.category.is_none());
    }

    #[test]
    fn completed_span() {
        let mut span = ToolSpan::new("call-2".into(), "write".into(), serde_json::json!({}));
        span.status = Some(SpanStatus::Ok);
        span.result = Some(serde_json::json!({"written": true}));
        span.ended_at = Some(span.started_at + 100_000);
        span.duration_ms = Some(100);
        assert!(span.is_complete());
    }

    #[test]
    fn span_serde_roundtrip() {
        let span = ToolSpan::new(
            "call-3".into(),
            "exec".into(),
            serde_json::json!({"cmd": "ls"}),
        );
        let json = serde_json::to_string(&span).unwrap();
        let back: ToolSpan = serde_json::from_str(&json).unwrap();
        assert_eq!(back.call_id, "call-3");
        assert_eq!(back.tool_name, "exec");
    }
}