dynamo-llm 1.6.2

Dynamo LLM Library
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

// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0

use tonic::{Code, Status, metadata::MetadataValue};

use super::RelayErrorReason;

pub const RELAY_ERROR_REASON_HEADER: &str = "kv-relay-error-reason";

impl RelayErrorReason {
    pub(crate) fn status(self, message: impl Into<String>) -> Status {
        let code = match self {
            Self::ContractMismatch
            | Self::ProducerChanged
            | Self::InvalidPublication
            | Self::UnsupportedFeature => Code::FailedPrecondition,
            Self::InvalidRequest => Code::InvalidArgument,
            Self::PoolNotFound => Code::NotFound,
            Self::ResourceLimit | Self::SubscriberLagged | Self::SnapshotProgressTimeout => {
                Code::ResourceExhausted
            }
            Self::PublicationUnavailable => Code::Unavailable,
            Self::Internal | Self::Unspecified => Code::Internal,
        };
        let mut status = Status::new(code, message);
        // Protobuf enum names contain only ASCII identifier characters.
        status.metadata_mut().insert(
            RELAY_ERROR_REASON_HEADER,
            MetadataValue::from_static(self.as_str_name()),
        );
        status
    }
}

/// Decode a known reason; absent, unknown and unspecified values require code-based fallback.
pub fn relay_error_reason(status: &Status) -> Option<RelayErrorReason> {
    let value = status
        .metadata()
        .get(RELAY_ERROR_REASON_HEADER)?
        .to_str()
        .ok()?;
    RelayErrorReason::from_str_name(value).filter(|reason| *reason != RelayErrorReason::Unspecified)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn reasons_survive_metadata_without_parsing_diagnostic_text() {
        for (reason, code) in [
            (RelayErrorReason::ContractMismatch, Code::FailedPrecondition),
            (RelayErrorReason::ProducerChanged, Code::FailedPrecondition),
            (RelayErrorReason::ResourceLimit, Code::ResourceExhausted),
            (RelayErrorReason::SubscriberLagged, Code::ResourceExhausted),
            (
                RelayErrorReason::SnapshotProgressTimeout,
                Code::ResourceExhausted,
            ),
        ] {
            let status = reason.status("arbitrary diagnostic text");
            assert_eq!(status.code(), code);
            assert_eq!(relay_error_reason(&status), Some(reason));
        }
        let mut status = Status::unavailable("transport error");
        assert_eq!(relay_error_reason(&status), None);
        for value in [
            "RELAY_ERROR_REASON_FUTURE",
            "RELAY_ERROR_REASON_UNSPECIFIED",
        ] {
            status
                .metadata_mut()
                .insert(RELAY_ERROR_REASON_HEADER, MetadataValue::from_static(value));
            assert_eq!(relay_error_reason(&status), None);
        }
    }
}