deepstrike-core 0.2.43

Cross-language agent runtime kernel — pure computation, zero I/O
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

use super::LoopStateMachine;
use crate::runtime::kernel::{CancellationReason, KernelObservation};
use crate::scheduler::state_machine::LoopAction;
use crate::scheduler::tcb::TaskLifecycle;
use crate::types::result::TerminationReason;

impl LoopStateMachine {
    /// Commit a host-owned cancellation after external I/O has already been stopped.
    pub fn cancel_operation(
        &mut self,
        operation_id: String,
        reason: CancellationReason,
        pending_call_ids: Vec<String>,
    ) -> LoopAction {
        self.observations.clear();

        let child_ids = self
            .tasks
            .all()
            .iter()
            .filter(|task| task.id.as_str() != "root" && !task.state.is_terminal())
            .map(|task| task.id.clone())
            .collect::<Vec<_>>();
        for child_id in child_ids {
            if let Some(task) = self.tasks.get_mut(child_id.as_str()) {
                task.state = TaskLifecycle::Done(TerminationReason::UserAbort);
                task.wait = None;
            }
        }

        self.suspend_state = None;
        self.pending_denied_results.clear();
        self.workflow = None;
        self.pending_workflow_spawn = None;
        self.pending_preempt = None;
        self.pending_host_effects.clear();
        self.active_host_effect = None;
        self.active_host_effect_failures = 0;
        self.deferred_action = None;
        self.pending_termination = None;
        self.pending_pace = None;

        self.observations
            .push(KernelObservation::OperationCancelled {
                turn: self.turn,
                operation_id,
                reason,
                pending_call_ids,
            });
        self.terminate(TerminationReason::UserAbort, None)
    }
}