sipp-rs 0.1.0

Unified Rust library for extensible Sipp inference
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
123
124
125
126
127
128
129
130
131
132
133

use std::{fmt, time::Duration};

/// Server-side adapter kind.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProviderKind {
    /// OpenAI-compatible adapter.
    OpenAiCompatible,
    /// OpenAI adapter.
    OpenAi,
    /// Anthropic adapter.
    Anthropic,
}

impl ProviderKind {
    /// Stable adapter label used in metadata and diagnostics.
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::OpenAiCompatible => "openai_compatible",
            Self::OpenAi => "openai",
            Self::Anthropic => "anthropic",
        }
    }
}

/// Redacted secret string.
#[derive(Clone, PartialEq, Eq)]
pub struct SecretString(String);

impl SecretString {
    /// Wrap a secret value.
    pub fn new(value: impl Into<String>) -> Self {
        Self(value.into())
    }

    /// Load a secret from an environment variable.
    pub fn from_env(name: impl AsRef<str>) -> Result<Self, std::env::VarError> {
        std::env::var(name.as_ref()).map(Self)
    }

    /// Expose the raw secret to adapter internals.
    pub fn expose(&self) -> &str {
        &self.0
    }

    pub(crate) fn is_blank(&self) -> bool {
        self.0.trim().is_empty()
    }

    pub(crate) fn contains_whitespace(&self) -> bool {
        self.0.chars().any(char::is_whitespace)
    }
}

impl fmt::Debug for SecretString {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str("SecretString([redacted])")
    }
}

/// Provider authentication owned by provider adapter configuration.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ProviderAuth {
    /// Bearer token authentication.
    Bearer(SecretString),
    /// Custom header authentication.
    Header { name: String, value: SecretString },
}

/// Wire protocol spoken by an OpenAI-compatible adapter.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OpenAiCompatibleProtocol {
    /// OpenAI-compatible chat, embeddings, models, and streaming routes.
    OpenAiCompatible,
}

/// OpenAI adapter configuration.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OpenAiAdapterConfig {
    /// OpenAI API key.
    pub api_key: SecretString,
    /// Optional OpenAI-compatible base URL.
    pub base_url: Option<String>,
    /// Request timeout.
    pub timeout: Option<Duration>,
}

/// Anthropic adapter configuration.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AnthropicAdapterConfig {
    /// Anthropic API key.
    pub api_key: SecretString,
    /// Optional Anthropic base URL.
    pub base_url: Option<String>,
    /// Optional Anthropic API version.
    pub version: Option<String>,
    /// Request timeout.
    pub timeout: Option<Duration>,
}

/// OpenAI-compatible adapter configuration.
#[derive(Clone, PartialEq, Eq)]
pub struct OpenAiCompatibleAdapterConfig {
    /// Provider-compatible base URL.
    pub base_url: String,
    /// Adapter authentication.
    pub auth: ProviderAuth,
    /// Wire protocol.
    pub protocol: OpenAiCompatibleProtocol,
    /// Static headers owned by provider configuration.
    pub static_headers: Vec<(String, String)>,
    /// Optional per-request correlation header.
    pub correlation_header: Option<String>,
    /// Request timeout.
    pub timeout: Option<Duration>,
}

impl fmt::Debug for OpenAiCompatibleAdapterConfig {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let static_headers = self
            .static_headers
            .iter()
            .map(|(name, _)| (name, "[redacted]"))
            .collect::<Vec<_>>();
        f.debug_struct("OpenAiCompatibleAdapterConfig")
            .field("base_url", &self.base_url)
            .field("auth", &self.auth)
            .field("protocol", &self.protocol)
            .field("static_headers", &static_headers)
            .field("correlation_header", &self.correlation_header)
            .field("timeout", &self.timeout)
            .finish()
    }
}