Struct AgentMetrics 

pub struct AgentMetrics {

    pub iterations: usize,
    pub tool_calls: usize,
    pub input_tokens: u32,
    pub output_tokens: u32,
    pub cache_read_tokens: u32,
    pub cache_creation_tokens: u32,
    pub execution_time_ms: u64,
    pub errors: usize,
    pub compactions: usize,
    pub api_calls: usize,
    pub total_cost_usd: f64,
    pub tool_stats: HashMap<String, ToolStats>,
    pub tool_call_records: Vec<ToolCallRecord>,
    pub model_usage: HashMap<String, ModelUsage>,
    pub server_tool_use: ServerToolUse,
    pub permission_denials: Vec<PermissionDenial>,
    pub api_time_ms: u64,
}

Fields

iterations: usize

tool_calls: usize

input_tokens: u32

output_tokens: u32

cache_read_tokens: u32

cache_creation_tokens: u32

execution_time_ms: u64

errors: usize

compactions: usize

api_calls: usize

total_cost_usd: f64

tool_stats: HashMap<String, ToolStats>

tool_call_records: Vec<ToolCallRecord>

model_usage: HashMap<String, ModelUsage>

server_tool_use: ServerToolUse

permission_denials: Vec<PermissionDenial>

api_time_ms: u64

Implementations

impl AgentMetrics

pub fn total_tokens(&self) -> u32

pub fn add_usage(&mut self, input: u32, output: u32)

pub fn add_usage_with_cache(&mut self, usage: &Usage)

pub fn cache_hit_rate(&self) -> f64

Calculate cache hit rate as a proportion of input tokens.

Returns the ratio of cache_read_tokens to input_tokens. A higher value means more tokens were served from cache.

pub fn cache_efficiency(&self) -> f64

Calculate cache efficiency (reads vs total cache operations).

Returns 1.0 for perfect cache reuse (all reads, no writes), and 0.0 when there’s no cache activity.

Per Anthropic pricing:

• Cache reads cost 10% of input tokens
• Cache writes cost 125% of input tokens

Higher efficiency = better cost savings.

pub fn cache_tokens_saved(&self) -> u32

Estimate tokens saved through caching.

Cache reads are billed at 10%, so 90% of read tokens are “saved”.

pub fn cache_cost_savings(&self, input_price_per_mtok: f64) -> f64

Calculate estimated cost savings from caching in USD.

Per Anthropic pricing:

• Normal input: full price
• Cache read: 10% of normal price (90% savings)
• Cache write: 125% of normal price (25% overhead)

Net savings = (cache_read * 0.9 * price) - (cache_write * 0.25 * price)

pub fn add_cost(&mut self, cost: f64)

pub fn record_tool( &mut self, tool_use_id: &str, name: &str, duration_ms: u64, is_error: bool, )

pub fn record_api_call(&mut self)

pub fn record_compaction(&mut self)

pub fn avg_tool_time_ms(&self) -> f64

pub fn record_model_usage(&mut self, model: &str, usage: &Usage)

Record usage for a specific model.

This enables per-model cost tracking like CLI’s modelUsage field.

pub fn record_api_call_with_timing(&mut self, duration_ms: u64)

Record an API call with timing information.

pub fn update_server_tool_use(&mut self, server_tool_use: &ServerToolUse)

Update server_tool_use from API response.

This is for server-side tools executed by the API (e.g., Anthropic’s server-side RAG). Not to be confused with local tool usage.

pub fn update_server_tool_use_from_api(&mut self, usage: &ServerToolUseUsage)

Update server_tool_use from API response’s usage.server_tool_use field.

This parses the server tool usage directly from the API response.

pub fn record_permission_denial(&mut self, denial: PermissionDenial)

Record a permission denial.

pub fn total_model_cost(&self) -> f64

Get the total cost across all models.

Trait Implementations

impl Clone for AgentMetrics

fn clone(&self) -> AgentMetrics

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AgentMetrics

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for AgentMetrics

fn default() -> AgentMetrics

Returns the “default value” for a type.