agentforge-core 0.1.10

Shared types, data models, and error types for AgentForge
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

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

/// Status of a shadow (online eval) run.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum ShadowRunStatus {
    Pending,
    Running,
    Complete,
    Error,
}

impl std::fmt::Display for ShadowRunStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ShadowRunStatus::Pending => write!(f, "pending"),
            ShadowRunStatus::Running => write!(f, "running"),
            ShadowRunStatus::Complete => write!(f, "complete"),
            ShadowRunStatus::Error => write!(f, "error"),
        }
    }
}

/// The outcome of comparing champion vs. candidate on a single dimension.
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum DimensionOutcome {
    Win,
    Loss,
    Tie,
}

/// Per-dimension comparison of champion vs. candidate.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DimensionComparison {
    pub dimension: String,
    pub champion_score: f64,
    pub candidate_score: f64,
    pub outcome: DimensionOutcome,
    pub delta: f64,
}

/// Aggregated shadow run comparison report.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ShadowComparison {
    pub run_id: Uuid,
    pub champion_agent_id: Uuid,
    pub candidate_agent_id: Uuid,
    /// Fraction of traffic routed to the candidate (0.0–1.0).
    pub traffic_fraction: f64,
    pub total_requests: u32,
    pub champion_aggregate_score: f64,
    pub candidate_aggregate_score: f64,
    pub aggregate_delta: f64,
    pub per_dimension: Vec<DimensionComparison>,
    /// Whether the candidate won overall (positive delta + all regression gates pass).
    pub candidate_wins: bool,
    pub compared_at: DateTime<Utc>,
}

/// Persisted record of a shadow run configuration.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ShadowRun {
    pub id: Uuid,
    pub champion_agent_id: Uuid,
    pub candidate_agent_id: Uuid,
    /// Percentage of traffic sent to candidate (0–100).
    pub traffic_percent: u8,
    pub status: ShadowRunStatus,
    pub comparison: Option<ShadowComparison>,
    pub error_message: Option<String>,
    pub created_at: DateTime<Utc>,
    pub started_at: Option<DateTime<Utc>>,
    pub completed_at: Option<DateTime<Utc>>,
}

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

    #[test]
    fn status_display() {
        assert_eq!(ShadowRunStatus::Pending.to_string(), "pending");
        assert_eq!(ShadowRunStatus::Complete.to_string(), "complete");
    }
}