Struct AnthropicClient 

pub struct AnthropicClient { /* private fields */ }

Available on crate features anthropic and models only.

Anthropic client for Claude models.

Implementations

impl AnthropicClient

pub fn new(config: AnthropicConfig) -> Result<AnthropicClient, AdkError>

Create a new Anthropic client.

pub fn from_api_key( api_key: impl Into<String>, ) -> Result<AnthropicClient, AdkError>

Create a client with just an API key (uses default model).

pub fn inner(&self) -> &Anthropic

Access the underlying adk_anthropic::Anthropic HTTP client.

Use this for direct API access to endpoints not covered by the Llm trait: batches, files, skills, models, token counting, and pricing.

let inner = anthropic_client.inner();
let models = inner.list_models(None).await?;
let batch = inner.create_batch(requests).await?;

pub fn with_default_headers(self, headers: HeaderMap) -> AnthropicClient

Adds default HTTP headers while preserving authentication and automatic beta headers.

Headers with the same name replace the existing default value. This method only stores the headers on the existing client, so unlike the OpenAI clients’ with_default_headers it cannot fail and returns Self.

Example

use adk_anthropic::{HeaderMap, HeaderValue};
use adk_model::anthropic::{AnthropicClient, AnthropicConfig};

let mut headers = HeaderMap::new();
headers.insert("x-session-id", HeaderValue::from_static("conversation-1"));
let client = AnthropicClient::new(AnthropicConfig::new("api-key", "claude-sonnet-4-6"))?
    .with_default_headers(headers);

pub fn anthropic_config(&self) -> &AnthropicConfig

Access the current Anthropic configuration.

pub fn with_retry_config(self, retry_config: RetryConfig) -> AnthropicClient

Set the retry configuration (builder pattern).

pub fn set_retry_config(&mut self, retry_config: RetryConfig)

Set the retry configuration (mutable reference).

pub fn retry_config(&self) -> &RetryConfig

Returns the current retry configuration.

pub async fn latest_rate_limit_info(&self) -> RateLimitInfo

Returns the latest rate-limit information from the most recent API response.

Updated after each API call when the server provides rate-limit headers via adk_anthropic::Error::RateLimit or adk_anthropic::Error::ServiceUnavailable. Returns the default (all None) if no rate-limit info has been received.

impl AnthropicClient

pub async fn list_models(&self) -> Result<Vec<ModelInfo>, AdkError>

List available Claude models.

Calls GET /v1/models and returns all model descriptors from the first page. For paginated access, use list_models_paginated.

Errors

Returns AdkError::Model with structured error context if the API returns an error.

pub async fn get_model(&self, model_id: &str) -> Result<ModelInfo, AdkError>

Get details for a specific model.

Calls GET /v1/models/{model_id} and returns the model descriptor.

Errors

Returns AdkError::Model with structured error context if the API returns an error (e.g., model not found).

impl AnthropicClient

pub async fn count_tokens( &self, request: &LlmRequest, ) -> Result<TokenCount, AdkError>

Count tokens for a request without generating a response.

Calls POST /v1/messages/count_tokens using the same request construction as generate_content, so system prompt extraction, multimodal mapping, and tool conversion all apply.

Errors

Returns AdkError::Model with structured error context if the API returns an error, consistent with the messages API.

Trait Implementations

impl Llm for AnthropicClient

fn name(&self) -> &str

Returns the model identifier (e.g., “gemini-2.5-flash”).

fn schema_adapter(&self) -> &dyn SchemaAdapter

Returns the schema adapter for this provider.

fn generate_content<'life0, 'async_trait>( &'life0 self, request: LlmRequest, stream: bool, ) -> Pin<Box<dyn Future<Output = Result<Pin<Box<dyn Stream<Item = Result<LlmResponse, AdkError>> + Send>>, AdkError>> + Send + 'async_trait>>

where 'life0: 'async_trait, AnthropicClient: 'async_trait,

Generates content from the given request, optionally streaming.

fn uses_interactions_api(&self) -> bool

Returns true if this model is configured to use a server-managed environment (e.g., Gemini Interactions API) where the provider owns the tool-calling loop and filesystem.