awaken-runtime 0.6.0

Phase-based execution engine, plugin system, and agent loop for Awaken
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
118
119

use awaken_protocol_a2a::TaskState;
use awaken_runtime_contract::contract::lifecycle::TerminationReason;

use super::{
    BackendRunStatus, TaskSnapshot, WAIT_REASON_AUTH_REQUIRED, WAIT_REASON_INPUT_REQUIRED,
    WAIT_REASON_TIMEOUT,
};

pub(super) enum PollCompletion {
    Finished(TaskSnapshot),
    TimedOut(TaskSnapshot),
}

pub(super) struct CompletionResult {
    pub(super) snapshot: TaskSnapshot,
    pub(super) status: BackendRunStatus,
    pub(super) termination: TerminationReason,
    pub(super) status_reason: Option<String>,
}

pub(super) fn map_completion_result(
    completion: PollCompletion,
    root_run: bool,
) -> CompletionResult {
    match completion {
        PollCompletion::TimedOut(snapshot) => CompletionResult {
            snapshot,
            status: BackendRunStatus::Timeout,
            termination: TerminationReason::stopped(WAIT_REASON_TIMEOUT),
            status_reason: Some(WAIT_REASON_TIMEOUT.to_string()),
        },
        PollCompletion::Finished(snapshot) => {
            let (status, termination, status_reason) = match snapshot.state {
                TaskState::Completed => (
                    BackendRunStatus::Completed,
                    TerminationReason::NaturalEnd,
                    None,
                ),
                TaskState::Canceled => (
                    BackendRunStatus::Cancelled,
                    TerminationReason::Cancelled,
                    None,
                ),
                TaskState::Failed => {
                    let message = snapshot
                        .failure_message
                        .clone()
                        .unwrap_or_else(|| "remote agent run failed".into());
                    (
                        BackendRunStatus::Failed(message.clone()),
                        TerminationReason::Error(message),
                        None,
                    )
                }
                TaskState::Rejected => {
                    let message = snapshot
                        .failure_message
                        .clone()
                        .unwrap_or_else(|| "remote agent rejected the task".into());
                    (
                        BackendRunStatus::Failed(message.clone()),
                        TerminationReason::Error(message),
                        None,
                    )
                }
                TaskState::InputRequired => {
                    interrupted_completion(snapshot.failure_message.clone(), root_run, false)
                }
                TaskState::AuthRequired => {
                    interrupted_completion(snapshot.failure_message.clone(), root_run, true)
                }
                TaskState::Submitted | TaskState::Working => (
                    BackendRunStatus::Failed("remote agent did not reach a terminal state".into()),
                    TerminationReason::Error("remote agent did not reach a terminal state".into()),
                    None,
                ),
            };
            CompletionResult {
                snapshot,
                status,
                termination,
                status_reason,
            }
        }
    }
}

fn interrupted_completion(
    failure_message: Option<String>,
    root_run: bool,
    auth_required: bool,
) -> (BackendRunStatus, TerminationReason, Option<String>) {
    let (default_message, wait_reason) = if auth_required {
        (
            "remote agent requires authentication",
            WAIT_REASON_AUTH_REQUIRED,
        )
    } else {
        (
            "remote agent requires additional input",
            WAIT_REASON_INPUT_REQUIRED,
        )
    };

    let message = if root_run {
        failure_message
    } else {
        Some(failure_message.unwrap_or_else(|| default_message.into()))
    };
    (
        if auth_required {
            BackendRunStatus::WaitingAuth(message)
        } else {
            BackendRunStatus::WaitingInput(message)
        },
        TerminationReason::Suspended,
        Some(wait_reason.to_string()),
    )
}