everruns-core 0.9.0

Core agent abstractions for Everruns - agent loop, events, tools, LLM providers
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

// Dependency blocker detection
//
// Decision: Shared module in core so both workers and activities don't
// duplicate harness/agent status checks and error messages.

use crate::error::Result;
use crate::traits::{AgentStore, HarnessStore};
use crate::typed_id::{AgentId, HarnessId};
use crate::{AgentStatus, HarnessStatus};

/// Reason why execution was blocked before it started.
#[derive(Debug, Clone, Copy)]
pub enum DependencyBlocker {
    HarnessArchived,
    HarnessDeleted,
    AgentArchived,
    AgentDeleted,
}

impl DependencyBlocker {
    /// User-facing message explaining why execution stopped.
    pub fn message(self) -> &'static str {
        match self {
            DependencyBlocker::HarnessArchived => {
                "Execution stopped because the assigned harness was archived."
            }
            DependencyBlocker::HarnessDeleted => {
                "Execution stopped because the assigned harness was deleted."
            }
            DependencyBlocker::AgentArchived => {
                "Execution stopped because the assigned agent was archived."
            }
            DependencyBlocker::AgentDeleted => {
                "Execution stopped because the assigned agent was deleted."
            }
        }
    }

    /// Error code for events.
    pub fn error_code(self) -> &'static str {
        "dependency_unavailable"
    }
}

/// Check if a harness/agent dependency is available for execution.
///
/// Returns `Some(blocker)` if execution should be blocked.
pub async fn detect_dependency_blocker(
    harness_store: &dyn HarnessStore,
    agent_store: &dyn AgentStore,
    harness_id: HarnessId,
    agent_id: Option<AgentId>,
) -> Result<Option<DependencyBlocker>> {
    let harness_chain = harness_store.get_harness_chain(harness_id).await?;
    match harness_chain.last() {
        Some(leaf) => match leaf.status {
            HarnessStatus::Active => {}
            HarnessStatus::Archived => return Ok(Some(DependencyBlocker::HarnessArchived)),
            HarnessStatus::Deleted => return Ok(Some(DependencyBlocker::HarnessDeleted)),
        },
        None => return Ok(Some(DependencyBlocker::HarnessDeleted)),
    }

    if let Some(agent_id) = agent_id {
        match agent_store.get_agent(agent_id).await? {
            Some(agent) => match agent.status {
                AgentStatus::Active => {}
                AgentStatus::Archived => return Ok(Some(DependencyBlocker::AgentArchived)),
                AgentStatus::Deleted => return Ok(Some(DependencyBlocker::AgentDeleted)),
            },
            None => return Ok(Some(DependencyBlocker::AgentDeleted)),
        }
    }

    Ok(None)
}