agentik-sdk 0.2.0

Comprehensive, type-safe Rust SDK for the Anthropic API with streaming, tools, vision, files, and batch processing support.
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

use reqwest::header::{HeaderValue, HeaderMap};
use crate::types::errors::{AnthropicError, Result};

/// Authentication method for different API gateways
#[derive(Debug, Clone)]
pub enum AuthMethod {
    /// Standard Anthropic API authentication with x-api-key header
    Anthropic,
    /// Bearer token authentication for custom gateways and third-party services
    Bearer,
    /// Custom token header (for compatibility with various gateways)
    Token,
}

/// Authentication handler for Anthropic API and compatible gateways
#[derive(Debug, Clone)]
pub struct AuthHandler {
    api_key: String,
    auth_method: AuthMethod,
}

impl AuthHandler {
    /// Create a new auth handler with standard Anthropic authentication
    pub fn new(api_key: String) -> Self {
        Self { 
            api_key,
            auth_method: AuthMethod::Anthropic,
        }
    }
    
    /// Create a new auth handler with Bearer token authentication
    pub fn new_bearer(api_key: String) -> Self {
        Self {
            api_key,
            auth_method: AuthMethod::Bearer,
        }
    }
    
    /// Create a new auth handler with custom token header
    pub fn new_token(api_key: String) -> Self {
        Self {
            api_key,
            auth_method: AuthMethod::Token,
        }
    }
    
    /// Create a new auth handler with specified method
    pub fn with_method(api_key: String, auth_method: AuthMethod) -> Self {
        Self {
            api_key,
            auth_method,
        }
    }
    
    /// Add authentication headers to the request
    pub fn add_auth_headers(&self, headers: &mut HeaderMap) -> Result<()> {
        match self.auth_method {
            AuthMethod::Anthropic => {
                let api_key_header = HeaderValue::from_str(&self.api_key)
                    .map_err(|_| AnthropicError::Configuration {
                        message: "Invalid API key format".to_string(),
                    })?;
                    
                headers.insert("x-api-key", api_key_header);
                headers.insert("anthropic-version", HeaderValue::from_static("2023-06-01"));
            }
            AuthMethod::Bearer => {
                let bearer_token = format!("Bearer {}", self.api_key);
                let auth_header = HeaderValue::from_str(&bearer_token)
                    .map_err(|_| AnthropicError::Configuration {
                        message: "Invalid API key format for Bearer token".to_string(),
                    })?;
                    
                headers.insert("authorization", auth_header);
                headers.insert("anthropic-version", HeaderValue::from_static("2023-06-01"));
            }
            AuthMethod::Token => {
                let token_header = HeaderValue::from_str(&self.api_key)
                    .map_err(|_| AnthropicError::Configuration {
                        message: "Invalid API key format for token header".to_string(),
                    })?;
                    
                headers.insert("token", token_header);
                headers.insert("anthropic-version", HeaderValue::from_static("2023-06-01"));
            }
        }
        
        headers.insert("content-type", HeaderValue::from_static("application/json"));
        
        Ok(())
    }
}