ferrin-core 0.1.1

Ferrin core: text generation loop, streaming pipeline, structured output, agents, middleware, registry.
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

//! Remove provider error bodies and opaque causes from telemetry copies.

use ferrin_spec::JsonValue;
use ferrin_spec::error::ApiCallError;
use ferrin_spec::error::EmptyResponseBodyError;
use ferrin_spec::error::InvalidArgumentError;
use ferrin_spec::error::InvalidPromptError;
use ferrin_spec::error::InvalidResponseDataError;
use ferrin_spec::error::JsonParseError;
use ferrin_spec::error::LoadApiKeyError;
use ferrin_spec::error::LoadSettingError;
use ferrin_spec::error::NoContentGeneratedError;
use ferrin_spec::error::ProviderError;
use ferrin_spec::error::TypeValidationError;
use ferrin_spec::error::UnsupportedFunctionalityError;

use super::TelemetryOptions;
use super::redact::REDACTED;

pub(super) fn redact_provider(error: &ProviderError, options: &TelemetryOptions) -> ProviderError {
    match error {
        ProviderError::ApiCall(error) => {
            let mut recorded = ApiCallError::new(REDACTED, error.url.clone());
            recorded.status_code = error.status_code;
            recorded.is_retryable = error.is_retryable;
            recorded.response_headers = error.response_headers.clone();
            if options.record_inputs {
                recorded.request_body = error.request_body.clone();
            } else {
                recorded.url.set_query(None);
                recorded.url.set_fragment(None);
            }
            if options.record_outputs {
                recorded.response_body = error.response_body.clone();
                recorded.data = error.data.clone();
            }
            recorded.into()
        }
        ProviderError::EmptyResponseBody(_) => EmptyResponseBodyError::new().into(),
        ProviderError::InvalidArgument(error) => {
            InvalidArgumentError::new(&error.argument, REDACTED).into()
        }
        ProviderError::InvalidPrompt(error) => {
            let mut recorded = InvalidPromptError::new(REDACTED);
            if options.record_inputs {
                recorded.prompt = error.prompt.clone();
            }
            recorded.into()
        }
        ProviderError::InvalidResponseData(error) => InvalidResponseDataError::new(
            REDACTED,
            if options.record_outputs {
                error.data.clone()
            } else {
                JsonValue::Null
            },
        )
        .into(),
        ProviderError::JsonParse(_) => ProviderError::JsonParse(Box::new(JsonParseError {
            text: REDACTED.into(),
            cause: REDACTED.into(),
        })),
        ProviderError::TypeValidation(_) => ProviderError::TypeValidation(TypeValidationError {
            value: JsonValue::Null,
            context: None,
            cause: REDACTED.into(),
        }),
        ProviderError::LoadApiKey(_) => LoadApiKeyError::new(REDACTED).into(),
        ProviderError::LoadSetting(_) => LoadSettingError::new(REDACTED).into(),
        ProviderError::NoContentGenerated(_) => NoContentGeneratedError::new().into(),
        ProviderError::NoSuchModel(error) => {
            let mut recorded = (**error).clone();
            recorded.message = REDACTED.into();
            recorded.into()
        }
        ProviderError::NoSuchProviderReference(error) => {
            let mut recorded = (**error).clone();
            recorded.message = REDACTED.into();
            if !options.record_inputs {
                recorded.reference = Default::default();
            }
            recorded.into()
        }
        ProviderError::TooManyEmbeddingValues(error) => (**error).clone().into(),
        ProviderError::UnsupportedFunctionality(error) => {
            UnsupportedFunctionalityError::with_message(&error.functionality, REDACTED).into()
        }
        ProviderError::Cancelled => ProviderError::Cancelled,
        ProviderError::Other(_) => ProviderError::message(REDACTED),
        _ => ProviderError::message(REDACTED),
    }
}