pmcp::types::auth

Struct AuthInfo

pub struct AuthInfo {
    pub scheme: AuthScheme,
    pub token: Option<String>,
    pub oauth: Option<OAuthInfo>,
    pub params: HashMap<String, Value>,
}

Expand description

Authentication information.

Fields§

§scheme: AuthScheme

Authentication scheme/type

§token: Option<String>

Authentication token

§oauth: Option<OAuthInfo>

OAuth-specific information

§params: HashMap<String, Value>

Additional authentication parameters

Implementations§

Source §

impl AuthInfo

Source

pub fn none() -> Self

Create auth info with no authentication.

§Examples

use pmcp::AuthInfo;

// Create auth info for endpoints that don't require authentication
let auth = AuthInfo::none();
assert!(!auth.is_required());
assert_eq!(auth.authorization_header(), None);

// Use in client configuration
let transport = StdioTransport::new();
let mut client = Client::new(transport);
// Client uses no auth by default

Source

pub fn bearer(token: impl Into<String>) -> Self

Create auth info with bearer token.

§Examples

use pmcp::AuthInfo;

// Create auth info with a bearer token
let auth = AuthInfo::bearer("my-api-token-123");
assert!(auth.is_required());
assert_eq!(auth.authorization_header(), Some("Bearer my-api-token-123".to_string()));

// Use environment variable for token
let token = std::env::var("API_TOKEN").unwrap_or_default();
let auth = AuthInfo::bearer(token);

// Use in client configuration with bearer auth
let auth2 = AuthInfo::bearer("secret-api-key");
// This auth info can be used when configuring HTTP transports

Source

pub fn oauth2(oauth: OAuthInfo) -> Self

Create auth info for OAuth.

§Examples

use pmcp::{AuthInfo, types::auth::{OAuthInfo, PkceMethod}};

// Configure OAuth 2.0 authentication
let oauth_info = OAuthInfo {
    auth_url: "https://auth.example.com/authorize".to_string(),
    token_url: "https://auth.example.com/token".to_string(),
    client_id: "my-client-id".to_string(),
    scopes: Some(vec!["read".to_string(), "write".to_string()]),
    redirect_uri: Some("http://localhost:8080/callback".to_string()),
    pkce_method: Some(PkceMethod::S256),
};

let auth = AuthInfo::oauth2(oauth_info);
assert!(auth.is_required());

// GitHub OAuth example
let github_oauth = OAuthInfo {
    auth_url: "https://github.com/login/oauth/authorize".to_string(),
    token_url: "https://github.com/login/oauth/access_token".to_string(),
    client_id: "your-github-app-id".to_string(),
    scopes: Some(vec!["repo".to_string(), "user:email".to_string()]),
    redirect_uri: Some("http://localhost:3000/auth/callback".to_string()),
    pkce_method: Some(PkceMethod::S256),
};

let github_auth = AuthInfo::oauth2(github_oauth);

Source

pub fn is_required(&self) -> bool

Check if authentication is required.

§Examples

use pmcp::{AuthInfo, types::auth::AuthScheme};

// No authentication
let no_auth = AuthInfo::none();
assert!(!no_auth.is_required());

// Bearer token authentication
let bearer_auth = AuthInfo::bearer("token");
assert!(bearer_auth.is_required());

// Custom authentication scheme
let mut custom_auth = AuthInfo::none();
custom_auth.scheme = AuthScheme::Custom("ApiKey".to_string());
assert!(custom_auth.is_required());

// Use in conditional logic
fn process_request(auth: &AuthInfo) {
    if auth.is_required() {
        println!("Authentication required: {:?}", auth.scheme);
    } else {
        println!("No authentication needed");
    }
}

Source

pub fn authorization_header(&self) -> Option<String>

Get the authorization header value if applicable.

§Examples

use pmcp::AuthInfo;
use std::collections::HashMap;

// Bearer token generates authorization header
let bearer_auth = AuthInfo::bearer("my-secret-token");
assert_eq!(
    bearer_auth.authorization_header(),
    Some("Bearer my-secret-token".to_string())
);

// No auth returns None
let no_auth = AuthInfo::none();
assert_eq!(no_auth.authorization_header(), None);

// OAuth returns None (uses different flow)
let oauth_auth = AuthInfo::oauth2(OAuthInfo {
    auth_url: "https://example.com/auth".to_string(),
    token_url: "https://example.com/token".to_string(),
    client_id: "client".to_string(),
    scopes: None,
    redirect_uri: None,
    pkce_method: None,
});
assert_eq!(oauth_auth.authorization_header(), None);

// Use in HTTP headers
let mut headers = HashMap::new();
if let Some(auth_header) = bearer_auth.authorization_header() {
    headers.insert("Authorization".to_string(), auth_header);
}