rig-typesafeai 0.46.0

Typed TypeSafe Jev judgments for Rig
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

//! Typed conversion after protocol validation.
use rig_core::error::ProviderError;
use serde::de::DeserializeOwned;

/// Direct conversion from a validated protocol answer into its application type.
pub(crate) trait DecodeAnswer: Sized {
    fn decode(answer: &crate::types::Answer) -> Result<Self, ProviderError>;
}

fn wrong_kind() -> ProviderError {
    ProviderError::Response("answer kind differs from question kind".into())
}

impl<T: DeserializeOwned + Ord> DecodeAnswer for crate::ChoiceAnswer<T> {
    fn decode(answer: &crate::types::Answer) -> Result<Self, ProviderError> {
        let crate::types::Answer::Choice {
            choice,
            probabilities,
            confidence,
        } = answer
        else {
            return Err(wrong_kind());
        };
        let label = |label: &str| -> Result<T, ProviderError> {
            Ok(T::deserialize(serde::de::value::StrDeserializer::<
                serde_json::Error,
            >::new(label))?)
        };
        Ok(Self {
            choice: label(choice)?,
            probabilities: probabilities
                .iter()
                .map(|(key, value)| Ok((label(key)?, *value)))
                .collect::<Result<_, ProviderError>>()?,
            confidence: *confidence,
        })
    }
}

fn index(key: &str) -> Result<usize, ProviderError> {
    key.parse()
        .map_err(|_| ProviderError::Response(format!("invalid score index: {key}")))
}

impl DecodeAnswer for crate::DynamicScoreAnswer {
    fn decode(answer: &crate::types::Answer) -> Result<Self, ProviderError> {
        let crate::types::Answer::Score {
            score,
            probabilities,
            legend,
            confidence,
        } = answer
        else {
            return Err(wrong_kind());
        };
        Ok(Self {
            score: *score,
            probabilities: probabilities
                .iter()
                .map(|(key, value)| Ok((index(key)?, *value)))
                .collect::<Result<_, ProviderError>>()?,
            legend: legend
                .iter()
                .map(|(key, value)| Ok((index(key)?, value.clone())))
                .collect::<Result<_, ProviderError>>()?,
            confidence: *confidence,
        })
    }
}

impl DecodeAnswer for crate::NoulAnswer {
    fn decode(answer: &crate::types::Answer) -> Result<Self, ProviderError> {
        let crate::types::Answer::Noul { noul } = answer else {
            return Err(wrong_kind());
        };
        Ok(Self { noul: *noul })
    }
}