yoagent-state 0.2.0

Durable state and lineage for long-running agents.
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

use crate::{ActorRef, ArtifactRef, NodeId, PatchId};
use serde::{Deserialize, Serialize};
use serde_json::Value as JsonValue;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum StateOp {
    CreateNode {
        id: NodeId,
        kind: String,
        props: JsonValue,
    },
    UpdateNode {
        id: NodeId,
        props: JsonValue,
    },
    TombstoneNode {
        id: NodeId,
        reason: String,
    },
    CreateRelation {
        from: NodeId,
        rel: String,
        to: NodeId,
        props: JsonValue,
    },
    DeleteRelation {
        from: NodeId,
        rel: String,
        to: NodeId,
    },
    MarkStale {
        id: NodeId,
        reason: String,
    },
    AttachArtifact {
        id: NodeId,
        artifact: ArtifactRef,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StatePatch {
    pub id: PatchId,
    pub title: String,
    pub summary: String,
    pub base_state_version: u64,
    pub base_project_ref: Option<ProjectRef>,
    pub ops: Vec<StateOp>,
    pub preconditions: Vec<Precondition>,
    pub expected_effects: Vec<ExpectedEffect>,
    pub evidence: Vec<NodeId>,
    pub artifacts: Vec<ArtifactRef>,
    pub status: PatchStatus,
    pub created_by: ActorRef,
}

impl StatePatch {
    pub fn new(
        id: PatchId,
        title: impl Into<String>,
        summary: impl Into<String>,
        created_by: ActorRef,
    ) -> Self {
        Self {
            id,
            title: title.into(),
            summary: summary.into(),
            base_state_version: 0,
            base_project_ref: None,
            ops: Vec::new(),
            preconditions: Vec::new(),
            expected_effects: Vec::new(),
            evidence: Vec::new(),
            artifacts: Vec::new(),
            status: PatchStatus::Proposed,
            created_by,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub enum PatchStatus {
    Proposed,
    AppliedInFork,
    Evaluated,
    Approved,
    Rejected,
    Promoted,
    Stale,
    Conflicted,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ProjectRef {
    pub repo: String,
    pub branch: Option<String>,
    pub commit: Option<String>,
    pub worktree: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Precondition {
    StateVersionIs(u64),
    ProjectCommitIs(String),
    NodeExists(NodeId),
    NodeDoesNotExist(NodeId),
    TestStillFailing { name: String },
    FileHashIs { path: String, hash: String },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum ExpectedEffect {
    TestPasses { name: String },
    EvalScoreAtLeast { metric: String, value: f64 },
    FailureResolved { failure: NodeId },
    NoRegression { metric: String },
}