Module: LlmCostTracker::Integrations::Anthropic

Extended by:
Base
Defined in:
lib/llm_cost_tracker/integrations/anthropic.rb

Defined Under Namespace

Modules: MessagesPatch

Constant Summary

Constants included from Base

Base::Result

Class Method Summary collapse

Methods included from Base

active?, enforce_budget!, install, minimum_version, normalize_sdk_args, object_dig, object_value, patch_target, patch_targets, record_safely, request_params, status, stream_collector, stream_pricing_mode, track_stream, version_constant

Class Method Details

.inference_geo(request:, usage:) ⇒ Object 



125
126
127
 
# File 'lib/llm_cost_tracker/integrations/anthropic.rb', line 125

def inference_geo(request:, usage:)
  object_value(usage, :inference_geo) || request[:inference_geo]
end

.integration_name ⇒ Object 



14
15
16
 
# File 'lib/llm_cost_tracker/integrations/anthropic.rb', line 14

def integration_name
  :anthropic
end

.minimum_version ⇒ Object 



18
19
20
 
# File 'lib/llm_cost_tracker/integrations/anthropic.rb', line 18

def minimum_version
  "1.36.0"
end

.patch_targets ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
 
# File 'lib/llm_cost_tracker/integrations/anthropic.rb', line 26

def patch_targets
  [
    patch_target("Anthropic::Resources::Messages", with: MessagesPatch, methods: %i[create stream stream_raw]),
    patch_target(
      "Anthropic::Resources::Beta::Messages",
      with: MessagesPatch,
      methods: %i[create stream stream_raw],
      optional: true
    )
  ]
end

.pricing_mode(request:, usage:) ⇒ Object 



106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/llm_cost_tracker/integrations/anthropic.rb', line 106

def pricing_mode(request:, usage:)
  service_tier = object_value(usage, :service_tier) || request[:service_tier]
  tier = Providers::Anthropic::TierClassification
  service_tier = nil if tier.standard_equivalent_tier?(service_tier)

  modes = [
    Pricing::Mode.normalize(object_value(usage, :speed) || request[:speed]),
    Pricing::Mode.normalize(service_tier)
  ]
  geo = inference_geo(request: request, usage: usage).to_s.downcase
  modes << "data_residency" if tier.data_residency_geo?(geo)
  modes = modes.compact.uniq
  modes.empty? ? nil : modes.join("_")
end

.record_message(message, request:, latency_ms:) ⇒ Object 



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
 
# File 'lib/llm_cost_tracker/integrations/anthropic.rb', line 38

def record_message(message, request:, latency_ms:)
  return unless active?

  record_safely do
    usage = object_value(message, :usage)
    next unless usage

    input_tokens = object_value(usage, :input_tokens)
    output_tokens = object_value(usage, :output_tokens)
    next if input_tokens.nil? && output_tokens.nil?

    LlmCostTracker::Tracker.record(
      event: Event.build(
        provider: "anthropic",
        model: object_value(message, :model) || request[:model],
        pricing_mode: pricing_mode(request: request, usage: usage),
        token_usage: token_usage(usage: usage, input_tokens: input_tokens, output_tokens: output_tokens),
        usage_source: :sdk_response,
        provider_response_id: object_value(message, :id),
        service_line_items: service_line_items_from(usage)
      ),
      latency_ms: latency_ms
    )
  end
end

.service_line_items_from(usage) ⇒ Object 



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
 
# File 'lib/llm_cost_tracker/integrations/anthropic.rb', line 64

def service_line_items_from(usage)
  server_tool_use = object_value(usage, :server_tool_use)
  return [] unless server_tool_use

  Providers::Anthropic::ServerTools::LINE_ITEMS.filter_map do |component_key, count_key|
    quantity = object_value(server_tool_use, count_key).to_i
    next if quantity.zero?

    Billing::LineItem.build(
      component_key: component_key,
      quantity: quantity,
      cost_status: Billing::CostStatus::UNKNOWN,
      pricing_basis: :provider_usage,
      provider_field: "usage.server_tool_use.#{count_key}"
    )
  end
end

.stream_pricing_mode(request) ⇒ Object 



121
122
123
 
# File 'lib/llm_cost_tracker/integrations/anthropic.rb', line 121

def stream_pricing_mode(request)
  pricing_mode(request: request || {}, usage: nil)
end

.token_usage(usage:, input_tokens:, output_tokens:) ⇒ Object 



82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
 
# File 'lib/llm_cost_tracker/integrations/anthropic.rb', line 82

def token_usage(usage:, input_tokens:, output_tokens:)
  cache_creation = object_value(usage, :cache_creation)
  if cache_creation
    cache_write_default = object_value(cache_creation, :ephemeral_5m_input_tokens).to_i
    cache_write_extended = object_value(cache_creation, :ephemeral_1h_input_tokens).to_i
  else
    cache_write_default = object_value(usage, :cache_creation_input_tokens).to_i
    cache_write_extended = 0
  end
  hidden_output = (
    object_value(usage, :thinking_tokens, :thinking_output_tokens) ||
    object_dig(usage, :output_tokens_details, :reasoning_tokens)
  ).to_i

  TokenUsage.build(
    input_tokens: input_tokens.to_i,
    output_tokens: output_tokens.to_i,
    cache_read_input_tokens: object_value(usage, :cache_read_input_tokens).to_i,
    cache_write_input_tokens: cache_write_default,
    cache_write_extended_input_tokens: cache_write_extended,
    hidden_output_tokens: hidden_output
  )
end

.version_constant ⇒ Object 



22
23
24
 
# File 'lib/llm_cost_tracker/integrations/anthropic.rb', line 22

def version_constant
  "Anthropic::VERSION"
end

.wrap_blocking_call(args, kwargs) ⇒ Object 



137
138
139
140
141
142
143
144
 
# File 'lib/llm_cost_tracker/integrations/anthropic.rb', line 137

def wrap_blocking_call(args, kwargs)
  request = request_params(args, kwargs)
  enforce_budget!(request: request)
  started_at = LlmCostTracker::Timing.now_monotonic
  message = yield
  record_message(message, request: request, latency_ms: LlmCostTracker::Timing.elapsed_ms(started_at))
  message
end

.wrap_stream_call(args, kwargs) ⇒ Object 



129
130
131
132
133
134
135
 
# File 'lib/llm_cost_tracker/integrations/anthropic.rb', line 129

def wrap_stream_call(args, kwargs)
  request = request_params(args, kwargs)
  enforce_budget!(request: request)
  collector = stream_collector(request)
  stream = yield
  track_stream(stream, collector: collector)
end