tokenr-ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ce5be4fe9dded47d914a3e7e348b86b807d90a53b75d2e875c7a63e24d52344b
+  data.tar.gz: 8b36455f2b65965afd9b304e88c467117b0e3d14abbdf3e3e05449ec34092a69
+SHA512:
+  metadata.gz: aeec3f6ee5c391a14f503c666989cd14bb62e1693dcd320a2b695a9f0fbed01c73107909f60a88b4191ce6421308cc375b1ed295e7095e4a8f3f8b3829bcf158
+  data.tar.gz: bc7c5d3133f07e146020eb3946a96956563003a068746296537259ba2361e769aab4bb8b39efeb92f601c6c0278c43155a86599846119770c09feba88e1bcf60

data/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to the Tokenr Ruby SDK will be documented here.
+
+## [0.1.0] - 2025-02-22
+
+### Added
+- Initial release
+- `Tokenr.configure` block-style configuration
+- `Tokenr.track` for manual tracking
+- `Tokenr.track_batch` for bulk tracking
+- `Tokenr::Integrations::OpenAI.wrap` — auto-tracks chat, completions, and embeddings
+- `Tokenr::Integrations::Anthropic.wrap` — auto-tracks messages
+- Async batched delivery via background `Thread` — zero runtime dependencies
+- `Tokenr.costs` and related query helpers

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tokenr
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,231 @@
+# tokenr Ruby SDK
+
+**Automatic LLM cost tracking in a few lines of code.**
+
+Track costs from OpenAI, Anthropic, and other LLM providers with minimal code changes. Get real-time visibility into spending by agent, feature, team, or any dimension you need.
+
+[![Gem Version](https://badge.fury.io/rb/tokenr-ruby.svg)](https://rubygems.org/gems/tokenr-ruby)
+
+## Features
+
+- **Minimal setup** — configure once, wrap your client, you're done
+- **Async by default** — batches requests in a background thread; never adds latency
+- **Multi-provider** — OpenAI and Anthropic today; manual tracking for anything else
+- **Rich attribution** — agent, feature, team, and custom tags per request
+- **Production-ready** — tracking failures are silent; your app always runs
+
+## Installation
+
+```ruby
+# Gemfile
+gem "tokenr-ruby"
+```
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install tokenr-ruby
+```
+
+> The gem is named `tokenr-ruby` on RubyGems. Once installed, you `require "tokenr"` as normal.
+
+## Quickstart
+
+### OpenAI
+
+```ruby
+require "openai"
+require "tokenr"
+
+Tokenr.configure do |c|
+  c.api_key  = ENV["TOKENR_TOKEN"]
+  c.agent_id = "my-app"           # optional default
+end
+
+client  = OpenAI::Client.new(access_token: ENV["OPENAI_API_KEY"])
+tracked = Tokenr::Integrations::OpenAI.wrap(client)
+
+response = tracked.chat(parameters: {
+  model:    "gpt-4o",
+  messages: [{ role: "user", content: "Hello!" }]
+})
+# Cost is automatically tracked to Tokenr
+```
+
+### Anthropic
+
+```ruby
+require "anthropic"
+require "tokenr"
+
+Tokenr.configure do |c|
+  c.api_key = ENV["TOKENR_TOKEN"]
+end
+
+client  = Anthropic::Client.new(api_key: ENV["ANTHROPIC_API_KEY"])
+tracked = Tokenr::Integrations::Anthropic.wrap(client)
+
+response = tracked.messages(
+  model:      "claude-opus-4-5",
+  max_tokens: 1024,
+  messages:   [{ role: "user", content: "Hello!" }]
+)
+# Automatically tracked!
+```
+
+## Configuration
+
+### Environment Variables
+
+```bash
+export TOKENR_TOKEN="your-token"
+```
+
+```ruby
+Tokenr.configure do |c|
+  c.api_key = ENV["TOKENR_TOKEN"]  # or it's read automatically
+end
+```
+
+### All Options
+
+```ruby
+Tokenr.configure do |c|
+  c.api_key        = ENV["TOKENR_TOKEN"]     # required
+  c.agent_id       = "my-app"                # default agent ID for all requests
+  c.team_id        = nil                     # default team ID
+  c.default_tags   = { environment: "prod" } # merged into every request
+  c.async          = true                    # send in background (recommended)
+  c.batch_size     = 100                     # flush after this many queued events
+  c.flush_interval = 5                       # flush every N seconds
+end
+```
+
+### Disable in Development
+
+```ruby
+Tokenr.configure do |c|
+  c.api_key = ENV["TOKENR_TOKEN"]
+  c.async   = ENV["RAILS_ENV"] == "production"
+end
+```
+
+## Advanced Usage
+
+### Track by Agent
+
+```ruby
+# Option 1: default at configure time
+Tokenr.configure { |c| c.agent_id = "support-bot" }
+
+# Option 2: per-wrapper
+tracked = Tokenr::Integrations::OpenAI.wrap(client, agent_id: "sales-bot")
+```
+
+### Track by Feature
+
+```ruby
+tracked = Tokenr::Integrations::OpenAI.wrap(client,
+  agent_id:     "support-bot",
+  feature_name: "ticket-summary"
+)
+```
+
+### Multi-Tenant Tracking
+
+```ruby
+# Wrap with a team_id to roll up costs per customer/team
+def ai_client_for(team)
+  Tokenr::Integrations::OpenAI.wrap(
+    base_client,
+    agent_id: "shared-bot",
+    tags:     { team_id: team.id, plan: team.plan }
+  )
+end
+```
+
+### Custom Tags
+
+```ruby
+tracked = Tokenr::Integrations::Anthropic.wrap(client,
+  tags: { customer_id: "cust_123", language: "es" }
+)
+```
+
+### Manual Tracking
+
+For providers without a built-in integration, or when you want explicit control:
+
+```ruby
+Tokenr.track(
+  provider:      "cohere",
+  model:         "command-r-plus",
+  input_tokens:  1200,
+  output_tokens: 400,
+  agent_id:      "research-bot",
+  feature_name:  "summarization",
+  latency_ms:    320
+)
+```
+
+### Querying Costs
+
+```ruby
+# Costs for the last 7 days
+Tokenr.costs(start_date: 7.days.ago.iso8601, end_date: Time.now.iso8601)
+
+# Grouped by agent
+Tokenr.client.get_costs_by_agent(limit: 20)
+
+# Time-series
+Tokenr.client.get_timeseries(interval: "day")
+```
+
+## How It Works
+
+1. `Tokenr::Integrations::OpenAI.wrap(client)` returns a thin wrapper around your existing client
+2. After each call the wrapper reads token counts from the response `usage` field
+3. Events are pushed onto an in-process queue and flushed to Tokenr in the background
+4. If tracking fails for any reason, the exception is swallowed — your app is unaffected
+5. On process exit, `at_exit` flushes any remaining queued events
+
+## Supported Providers
+
+| Provider  | Auto-Tracking | Manual Tracking |
+|-----------|:-------------:|:---------------:|
+| OpenAI    | Yes           | Yes             |
+| Anthropic | Yes           | Yes             |
+| Cohere    | Coming soon   | Yes             |
+| Custom    | —             | Yes             |
+
+## Getting Your API Token
+
+1. Sign up at [tokenr.co](https://tokenr.co)
+2. Go to **API Tokens** and create a token
+3. Copy it — shown only once
+
+```bash
+export TOKENR_TOKEN="your-token-here"
+```
+
+## Security
+
+This SDK is open source so you can audit exactly what data is sent and when. The short version:
+
+- Only token counts, model names, and your attribution metadata are transmitted
+- No prompt content or response content ever leaves your application
+- All requests use HTTPS
+- Tracking runs on a background thread and cannot block your main thread
+
+## License
+
+MIT — see [LICENSE.txt](LICENSE.txt)
+
+## Support
+
+- Issues: [github.com/tokenr-co/tokenr-ruby/issues](https://github.com/tokenr-co/tokenr-ruby/issues)
+- Email: support@tokenr.co

data/lib/tokenr/client.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+
+module Tokenr
+  class Client
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def track(data)
+      config.validate!
+      post("/api/v1/track", data)
+    end
+
+    def track_batch(requests)
+      config.validate!
+      post("/api/v1/track/batch", { requests: requests })
+    end
+
+    def get_costs(start_date: nil, end_date: nil, agent_id: nil, model: nil, group_by: nil)
+      config.validate!
+      params = {}
+      params[:start_date] = start_date if start_date
+      params[:end_date]   = end_date   if end_date
+      params[:agent_id]   = agent_id   if agent_id
+      params[:model]      = model      if model
+      params[:group_by]   = group_by   if group_by
+      get("/api/v1/costs", params)
+    end
+
+    def get_costs_by_agent(limit: 50)
+      config.validate!
+      get("/api/v1/costs/agents", { limit: limit })
+    end
+
+    def get_costs_by_model
+      config.validate!
+      get("/api/v1/costs/models")
+    end
+
+    def get_timeseries(interval: "day", **filters)
+      config.validate!
+      get("/api/v1/costs/timeseries", filters.merge(interval: interval))
+    end
+
+    def token_info
+      config.validate!
+      get("/api/v1/tokens/me")
+    end
+
+    private
+
+    def post(path, body)
+      request(:post, path, body)
+    end
+
+    def get(path, params = {})
+      request(:get, path, nil, params)
+    end
+
+    def request(method, path, body = nil, params = {})
+      uri  = build_uri(path, params)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl       = uri.scheme == "https"
+      http.open_timeout  = 5
+      http.read_timeout  = 30
+
+      req = build_request(method, uri, body)
+      handle_response(http.request(req))
+    end
+
+    def build_uri(path, params = {})
+      uri = URI.join(config.api_base, path)
+      uri.query = URI.encode_www_form(params) if params.any?
+      uri
+    end
+
+    def build_request(method, uri, body)
+      req = case method
+            when :post then Net::HTTP::Post.new(uri)
+            when :get  then Net::HTTP::Get.new(uri)
+            else raise ArgumentError, "Unsupported HTTP method: #{method}"
+            end
+
+      req["Authorization"] = "Bearer #{config.api_key}"
+      req["Content-Type"]  = "application/json"
+      req["User-Agent"]    = "tokenr-ruby/#{VERSION}"
+      req.body = body.to_json if body
+      req
+    end
+
+    def handle_response(response)
+      case response.code.to_i
+      when 200..299
+        JSON.parse(response.body, symbolize_names: true)
+      when 401
+        raise ApiError, "Unauthorized: invalid API key"
+      when 403
+        raise ApiError, "Forbidden: insufficient token permissions"
+      when 422
+        data = JSON.parse(response.body, symbolize_names: true)
+        raise ApiError, "Validation error: #{data[:error]}"
+      else
+        raise ApiError, "API error (#{response.code}): #{response.body}"
+      end
+    end
+  end
+end

data/lib/tokenr/configuration.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Tokenr
+  class Configuration
+    attr_accessor :api_key, :api_base, :agent_id, :team_id, :default_tags,
+                  :async, :batch_size, :flush_interval
+
+    def initialize
+      @api_key        = ENV["TOKENR_TOKEN"]
+      @api_base       = ENV["TOKENR_API_BASE"] || "https://tokenr.co"
+      @agent_id       = nil
+      @team_id        = nil
+      @default_tags   = {}
+      @async          = true
+      @batch_size     = 100
+      @flush_interval = 5
+    end
+
+    def valid?
+      !api_key.nil? && !api_key.empty?
+    end
+
+    def validate!
+      raise ConfigurationError, "API key is required. Set TOKENR_TOKEN or pass api_key to Tokenr.configure." unless valid?
+    end
+  end
+end

data/lib/tokenr/integrations/anthropic.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Tokenr
+  module Integrations
+    # Wrap an Anthropic client to automatically track costs.
+    #
+    # Usage:
+    #   require "anthropic"
+    #   require "tokenr"
+    #
+    #   Tokenr.configure { |c| c.api_key = ENV["TOKENR_TOKEN"] }
+    #
+    #   client  = Anthropic::Client.new(api_key: ENV["ANTHROPIC_API_KEY"])
+    #   tracked = Tokenr::Integrations::Anthropic.wrap(client, agent_id: "my-bot")
+    #
+    #   response = tracked.messages(
+    #     model:     "claude-opus-4-5",
+    #     max_tokens: 1024,
+    #     messages:  [{ role: "user", content: "Hello!" }]
+    #   )
+    #   # Cost is tracked automatically — no other changes needed.
+    #
+    module Anthropic
+      class << self
+        def wrap(client, agent_id: nil, feature_name: nil, tags: {})
+          Wrapper.new(client, agent_id: agent_id, feature_name: feature_name, tags: tags)
+        end
+      end
+
+      class Wrapper
+        attr_reader :client, :agent_id, :feature_name, :tags
+
+        def initialize(client, agent_id: nil, feature_name: nil, tags: {})
+          @client       = client
+          @agent_id     = agent_id
+          @feature_name = feature_name
+          @tags         = tags
+        end
+
+        def messages(model:, messages:, **params)
+          start    = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          response = client.messages(model: model, messages: messages, **params)
+          latency  = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
+
+          track_response(model, response, latency)
+          response
+        end
+
+        def method_missing(method, *args, **kwargs, &block)
+          client.send(method, *args, **kwargs, &block)
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          client.respond_to?(method, include_private)
+        end
+
+        private
+
+        def track_response(model, response, latency_ms)
+          usage = response.usage
+          return unless usage
+
+          Tokenr.track(
+            model:         model,
+            provider:      "anthropic",
+            input_tokens:  usage.input_tokens  || 0,
+            output_tokens: usage.output_tokens || 0,
+            latency_ms:    latency_ms,
+            agent_id:      agent_id,
+            feature_name:  feature_name,
+            tags:          tags
+          )
+        rescue StandardError
+          # Never let tracking errors surface to the caller
+        end
+      end
+    end
+  end
+end

data/lib/tokenr/integrations/openai.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Tokenr
+  module Integrations
+    # Wrap an OpenAI client to automatically track costs.
+    #
+    # Usage:
+    #   require "openai"
+    #   require "tokenr"
+    #
+    #   Tokenr.configure { |c| c.api_key = ENV["TOKENR_TOKEN"] }
+    #
+    #   client = OpenAI::Client.new(access_token: ENV["OPENAI_API_KEY"])
+    #   tracked = Tokenr::Integrations::OpenAI.wrap(client, agent_id: "my-bot")
+    #
+    #   response = tracked.chat(parameters: { model: "gpt-4o", messages: [...] })
+    #   # Cost is tracked automatically — no other changes needed.
+    #
+    module OpenAI
+      class << self
+        def wrap(client, agent_id: nil, feature_name: nil, tags: {})
+          Wrapper.new(client, agent_id: agent_id, feature_name: feature_name, tags: tags)
+        end
+      end
+
+      class Wrapper
+        attr_reader :client, :agent_id, :feature_name, :tags
+
+        def initialize(client, agent_id: nil, feature_name: nil, tags: {})
+          @client       = client
+          @agent_id     = agent_id
+          @feature_name = feature_name
+          @tags         = tags
+        end
+
+        def chat(parameters:)
+          timed { client.chat(parameters: parameters) } do |response, latency_ms|
+            track_chat_response(parameters[:model], response, latency_ms)
+          end
+        end
+
+        def completions(parameters:)
+          timed { client.completions(parameters: parameters) } do |response, latency_ms|
+            track_chat_response(parameters[:model], response, latency_ms)
+          end
+        end
+
+        def embeddings(parameters:)
+          timed { client.embeddings(parameters: parameters) } do |response, latency_ms|
+            usage = response.dig("usage")
+            next unless usage
+
+            Tokenr.track(
+              model:        parameters[:model],
+              provider:     "openai",
+              input_tokens: usage["prompt_tokens"] || 0,
+              output_tokens: 0,
+              latency_ms:   latency_ms,
+              agent_id:     agent_id,
+              feature_name: feature_name,
+              tags:         tags
+            )
+          end
+        end
+
+        # Pass any other methods straight through to the underlying client.
+        def method_missing(method, *args, **kwargs, &block)
+          client.send(method, *args, **kwargs, &block)
+        end
+
+        def respond_to_missing?(method, include_private = false)
+          client.respond_to?(method, include_private)
+        end
+
+        private
+
+        def timed
+          start    = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          response = yield
+          latency  = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
+          yield response, latency if block_given?
+          response
+        end
+
+        def track_chat_response(model, response, latency_ms)
+          usage = response.dig("usage")
+          return unless usage
+
+          Tokenr.track(
+            model:         model,
+            provider:      "openai",
+            input_tokens:  usage["prompt_tokens"]     || 0,
+            output_tokens: usage["completion_tokens"] || 0,
+            latency_ms:    latency_ms,
+            agent_id:      agent_id,
+            feature_name:  feature_name,
+            tags:          tags
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tokenr/tracker.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Tokenr
+  class Tracker
+    attr_reader :client, :queue
+
+    def initialize(client)
+      @client  = client
+      @queue   = []
+      @mutex   = Mutex.new
+      @flusher = nil
+      start_flusher if client.config.async
+    end
+
+    def track(model:, input_tokens:, output_tokens:, **options)
+      data = build_request(model, input_tokens, output_tokens, options)
+
+      if client.config.async
+        enqueue(data)
+      else
+        client.track(data)
+      end
+    end
+
+    def track_batch(requests)
+      formatted = requests.map do |r|
+        build_request(r[:model], r[:input_tokens], r[:output_tokens], r)
+      end
+
+      if client.config.async
+        formatted.each { |r| enqueue(r) }
+      else
+        client.track_batch(formatted)
+      end
+    end
+
+    def flush
+      to_send = nil
+      @mutex.synchronize do
+        return if @queue.empty?
+        to_send = @queue.dup
+        @queue.clear
+      end
+
+      to_send.each_slice(client.config.batch_size) do |batch|
+        client.track_batch(batch)
+      rescue StandardError => e
+        warn "[Tokenr] Flush error: #{e.message}"
+      end
+    end
+
+    def shutdown
+      @flusher&.kill
+      flush
+    end
+
+    private
+
+    def build_request(model, input_tokens, output_tokens, options)
+      config = client.config
+      {
+        model:        model,
+        input_tokens: input_tokens,
+        output_tokens: output_tokens,
+        agent_id:     options[:agent_id]     || config.agent_id,
+        team_id:      options[:team_id]      || config.team_id,
+        feature_name: options[:feature_name],
+        provider:     options[:provider],
+        latency_ms:   options[:latency_ms],
+        status:       options[:status]       || "success",
+        external_id:  options[:external_id],
+        total_cost:   options[:total_cost],
+        requested_at: options[:requested_at] || Time.now.iso8601,
+        tags:         config.default_tags.merge(options[:tags] || {}),
+        metrics:      options[:metrics]
+      }.compact
+    end
+
+    def enqueue(data)
+      @mutex.synchronize { @queue << data }
+      flush if @queue.size >= client.config.batch_size
+    end
+
+    def start_flusher
+      interval = client.config.flush_interval
+      @flusher = Thread.new do
+        loop do
+          sleep interval
+          flush
+        end
+      end
+      @flusher.abort_on_exception = false
+      at_exit { shutdown }
+    end
+  end
+end

data/lib/tokenr/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Tokenr
+  VERSION = "0.1.0"
+end

data/lib/tokenr.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "tokenr/version"
+require_relative "tokenr/configuration"
+require_relative "tokenr/client"
+require_relative "tokenr/tracker"
+require_relative "tokenr/integrations/openai"
+require_relative "tokenr/integrations/anthropic"
+
+module Tokenr
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+  class ApiError < Error; end
+
+  class << self
+    attr_accessor :configuration
+
+    # Configure the SDK.
+    #
+    #   Tokenr.configure do |c|
+    #     c.api_key   = ENV["TOKENR_TOKEN"]
+    #     c.agent_id  = "my-app"
+    #   end
+    #
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+
+    def client
+      @client ||= Client.new(configuration)
+    end
+
+    def tracker
+      @tracker ||= Tracker.new(client)
+    end
+
+    # Track a single LLM request.
+    def track(model:, input_tokens:, output_tokens:, **options)
+      tracker.track(model: model, input_tokens: input_tokens, output_tokens: output_tokens, **options)
+    end
+
+    # Track multiple LLM requests in one API call.
+    def track_batch(requests)
+      tracker.track_batch(requests)
+    end
+
+    # Query cost data from the Tokenr API.
+    def costs(**options)
+      client.get_costs(**options)
+    end
+
+    # Reset all module-level state (useful in tests).
+    def reset!
+      @client = nil
+      @tracker = nil
+      @configuration = nil
+    end
+  end
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: tokenr-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tokenr
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Track and attribute LLM costs across OpenAI, Anthropic, and other providers.
+  Async by default, never slows down your app. Supports per-request attribution by
+  agent, feature, team, and custom tags.
+email:
+- support@tokenr.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/tokenr.rb
+- lib/tokenr/client.rb
+- lib/tokenr/configuration.rb
+- lib/tokenr/integrations/anthropic.rb
+- lib/tokenr/integrations/openai.rb
+- lib/tokenr/tracker.rb
+- lib/tokenr/version.rb
+homepage: https://tokenr.co
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://tokenr.co
+  source_code_uri: https://github.com/tokenr-co/tokenr-ruby
+  changelog_uri: https://github.com/tokenr-co/tokenr-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Automatic LLM cost tracking for OpenAI, Anthropic, and more
+test_files: []