mesh-llm-runtime-event-contracts 0.78.1

Dependency-leaf producer contracts for mesh-llm runtime events
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
120
121
122

use crate::{
    DeliveryClass, ModelAvailabilityEventKind, ModelLoadingEventKind, ModelPreparationEventKind,
    ModelUnloadingEventKind, NativeRuntimeEventKind, SessionEventKind, StageTopologyEventKind,
};

pub(super) const fn native_runtime(kind: NativeRuntimeEventKind) -> DeliveryClass {
    match kind {
        NativeRuntimeEventKind::RuntimeResolutionCompleted
        | NativeRuntimeEventKind::RuntimeResolutionFailed
        | NativeRuntimeEventKind::RuntimeStopped
        | NativeRuntimeEventKind::RuntimeCrashed => DeliveryClass::Terminal,
        NativeRuntimeEventKind::RuntimeResolutionStarted
        | NativeRuntimeEventKind::NativeLibraryLoaded
        | NativeRuntimeEventKind::NativeLibraryRejected
        | NativeRuntimeEventKind::NativeLibraryUnavailable
        | NativeRuntimeEventKind::AbiFeatureCompatibilityEstablished
        | NativeRuntimeEventKind::AbiFeatureCompatibilityFailed
        | NativeRuntimeEventKind::RuntimeInitialized
        | NativeRuntimeEventKind::RuntimeStopping => DeliveryClass::StateTransition,
    }
}

pub(super) const fn model_preparation(kind: ModelPreparationEventKind) -> DeliveryClass {
    match kind {
        ModelPreparationEventKind::ModelDownloadProgress
        | ModelPreparationEventKind::ModelPreparationProgress => DeliveryClass::Progress,
        ModelPreparationEventKind::ModelResolutionCompleted
        | ModelPreparationEventKind::ModelResolutionFailed
        | ModelPreparationEventKind::ModelDownloadCompleted
        | ModelPreparationEventKind::ModelDownloadFailed
        | ModelPreparationEventKind::ModelDownloadCancelled
        | ModelPreparationEventKind::ModelPreparationCompleted
        | ModelPreparationEventKind::ModelPreparationFailed
        | ModelPreparationEventKind::ModelPreparationCancelled => DeliveryClass::Terminal,
        ModelPreparationEventKind::ModelQueued
        | ModelPreparationEventKind::ModelResolutionStarted
        | ModelPreparationEventKind::ModelDownloadStarted
        | ModelPreparationEventKind::ModelPreparationStarted => DeliveryClass::StateTransition,
    }
}

pub(super) const fn model_loading(kind: ModelLoadingEventKind) -> DeliveryClass {
    match kind {
        ModelLoadingEventKind::ModelLoadProgress => DeliveryClass::Progress,
        ModelLoadingEventKind::NativeModelLoadCompleted
        | ModelLoadingEventKind::ModelLoadFailed
        | ModelLoadingEventKind::ModelLoadCancelled => DeliveryClass::Terminal,
        ModelLoadingEventKind::ModelLoadRequested
        | ModelLoadingEventKind::ModelLoadStarted
        | ModelLoadingEventKind::ModelLoadPhaseChanged
        | ModelLoadingEventKind::BackendDeviceSelected
        | ModelLoadingEventKind::ModelMemoryAllocationSummary
        | ModelLoadingEventKind::ModelMemoryPressure => DeliveryClass::StateTransition,
    }
}

pub(super) const fn model_availability(kind: ModelAvailabilityEventKind) -> DeliveryClass {
    match kind {
        ModelAvailabilityEventKind::ModelAvailable
        | ModelAvailabilityEventKind::ModelUnavailable
        | ModelAvailabilityEventKind::ModelRecoveryCompleted
        | ModelAvailabilityEventKind::ModelRecoveryFailed => DeliveryClass::Terminal,
        ModelAvailabilityEventKind::NativeModelLoaded
        | ModelAvailabilityEventKind::RustBackendInitializationStarted
        | ModelAvailabilityEventKind::ModelDegraded
        | ModelAvailabilityEventKind::ModelRecoveryStarted
        | ModelAvailabilityEventKind::ModelCapacityChanged => DeliveryClass::StateTransition,
    }
}

pub(super) const fn model_unloading(kind: ModelUnloadingEventKind) -> DeliveryClass {
    match kind {
        ModelUnloadingEventKind::UnloadCompleted | ModelUnloadingEventKind::UnloadFailed => {
            DeliveryClass::Terminal
        }
        ModelUnloadingEventKind::UnloadRequested
        | ModelUnloadingEventKind::UnloadStarted
        | ModelUnloadingEventKind::SessionDrainingStarted
        | ModelUnloadingEventKind::SessionDrainingCompleted
        | ModelUnloadingEventKind::ForcedUnload => DeliveryClass::StateTransition,
    }
}

pub(super) const fn stage_topology(kind: StageTopologyEventKind) -> DeliveryClass {
    match kind {
        StageTopologyEventKind::StageReady
        | StageTopologyEventKind::StageStopped
        | StageTopologyEventKind::StageFailed
        | StageTopologyEventKind::TopologyReady
        | StageTopologyEventKind::TopologyUnavailable => DeliveryClass::Terminal,
        StageTopologyEventKind::StageStarting
        | StageTopologyEventKind::StageLoading
        | StageTopologyEventKind::StageDegraded
        | StageTopologyEventKind::StageUnavailable
        | StageTopologyEventKind::StageStopping
        | StageTopologyEventKind::TopologyAssembling
        | StageTopologyEventKind::TopologyDegraded
        | StageTopologyEventKind::StageConnectionEstablished
        | StageTopologyEventKind::StageConnectionLost
        | StageTopologyEventKind::StageConnectionRecovered => DeliveryClass::StateTransition,
    }
}

pub(super) const fn session(kind: SessionEventKind) -> DeliveryClass {
    match kind {
        SessionEventKind::SessionClosed | SessionEventKind::SessionFailed => {
            DeliveryClass::Terminal
        }
        SessionEventKind::SessionRequested
        | SessionEventKind::SessionCreated
        | SessionEventKind::SessionActive
        | SessionEventKind::SessionIdle
        | SessionEventKind::SessionReusable
        | SessionEventKind::SessionReset
        | SessionEventKind::SessionTrimmed
        | SessionEventKind::SessionRestoredFromPrefixCache
        | SessionEventKind::SessionRestoredFromCheckpoint
        | SessionEventKind::SessionDraining
        | SessionEventKind::SessionAbandoned
        | SessionEventKind::SessionReclaimed => DeliveryClass::StateTransition,
    }
}