riffer 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d44459cec1b14508aac77178786e7230640ad1d455ced72ebda4ff02166283e4
-  data.tar.gz: 58a86d78ac5025d17245596e5ab0680d740fc0345cc3d51f2e68a65c5f3b8641
+  metadata.gz: f5f2d3838897b17320d17d3cc95b1db37ae8af023d6dcac8c5c9ce0fa5a6e847
+  data.tar.gz: e7e75acdd198f147747d06bcaaddeba27f3491bcc12edd2ac0e35f464d47e2f0
 SHA512:
-  metadata.gz: 9f8816ae7deb524c786afd74096f55bad54102c32d246f706f7bf15ed1c47cb7cd4f2ccb30c05af833b80e4898049febf5df45c98b8085c7b15c0ed71f425c98
-  data.tar.gz: 4c2627096ae1181b34d710d744ff339a61ebde623c30c6ea1e000ddac82bf9b374c7eb0d23364f7821856b407466332cc26fedca6288e93b23f9785515d220e7
+  metadata.gz: 557d945daf22b6a45cb838532a5df0c811d2ac73377b2a5c445efb0dc06a8a2e9c234d14691333d699c6d0dddda7299a5e3bb5a676e4ae72d32b1f631c9694b4
+  data.tar.gz: aa35cbff64ef8c11e72e76c3c931589e8163f751b96c066cfef74a5f7779fabb8891565c4d215b2ea9b29fca45fb991ebd49260462c203aa9b73328f39d913ca

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.10.0"
+  ".": "0.11.0"
 }

data/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.11.0](https://github.com/janeapp/riffer/compare/riffer/v0.10.0...riffer/v0.11.0) (2026-02-04)
+
+
+### Features
+
+* add class methods for generate and stream to Riffer::Agent ([#97](https://github.com/janeapp/riffer/issues/97)) ([597636a](https://github.com/janeapp/riffer/commit/597636aef7498fe34c975522930e3fd0939a2ea0))
+* Add token usage tracking in Riffer::Agent ([#102](https://github.com/janeapp/riffer/pull/102)) ([6044914](https://github.com/janeapp/riffer/commit/60449148074e42a8b36f0b6977be005b06993d9c))
+
 ## [0.10.0](https://github.com/janeapp/riffer/compare/riffer/v0.9.0...riffer/v0.10.0) (2026-01-30)
 
 

data/docs/03_AGENTS.md

@@ -107,20 +107,24 @@ end
 Generates a response synchronously:
 
 ```ruby
-agent = MyAgent.new
+# Class method (recommended for simple calls)
+response = MyAgent.generate('Hello')
 
-# With a string prompt
+# Instance method (when you need message history or callbacks)
+agent = MyAgent.new
+agent.on_message { |msg| log(msg) }
 response = agent.generate('Hello')
+agent.messages  # Access message history
 
 # With message objects/hashes
-response = agent.generate([
+response = MyAgent.generate([
   {role: 'user', content: 'Hello'},
   {role: 'assistant', content: 'Hi there!'},
   {role: 'user', content: 'How are you?'}
 ])
 
 # With tool context
-response = agent.generate('Look up my orders', tool_context: {user_id: 123})
+response = MyAgent.generate('Look up my orders', tool_context: {user_id: 123})
 ```
 
 ### stream
@@ -128,9 +132,8 @@ response = agent.generate('Look up my orders', tool_context: {user_id: 123})
 Streams a response as an Enumerator:
 
 ```ruby
-agent = MyAgent.new
-
-agent.stream('Tell me a story').each do |event|
+# Class method (recommended for simple calls)
+MyAgent.stream('Tell me a story').each do |event|
   case event
   when Riffer::StreamEvents::TextDelta
     print event.content
@@ -140,6 +143,12 @@ agent.stream('Tell me a story').each do |event|
     puts "[Tool: #{event.name}]"
   end
 end
+
+# Instance method (when you need message history or callbacks)
+agent = MyAgent.new
+agent.on_message { |msg| persist_message(msg) }
+agent.stream('Tell me a story').each { |event| handle(event) }
+agent.messages  # Access message history
 ```
 
 ### messages
@@ -181,6 +190,23 @@ agent
 
 Works with both `generate` and `stream`. Only emits agent-generated messages (Assistant, Tool), not inputs (System, User).
 
+### token_usage
+
+Access cumulative token usage across all LLM calls:
+
+```ruby
+agent = MyAgent.new
+agent.generate("Hello!")
+
+if agent.token_usage
+  puts "Total tokens: #{agent.token_usage.total_tokens}"
+  puts "Input: #{agent.token_usage.input_tokens}"
+  puts "Output: #{agent.token_usage.output_tokens}"
+end
+```
+
+Returns `nil` if the provider doesn't report usage, or a `Riffer::TokenUsage` object with accumulated totals.
+
 ## Class Methods
 
 ### find

data/docs/05_MESSAGES.md

@@ -30,14 +30,15 @@ msg.to_h     # => {role: :user, content: "Hello, how are you?"}
 
 ### Assistant
 
-Assistant messages represent LLM responses, potentially including tool calls:
+Assistant messages represent LLM responses, potentially including tool calls and token usage data:
 
 ```ruby
 # Text-only response
 msg = Riffer::Messages::Assistant.new("I'm doing well, thank you!")
-msg.role        # => :assistant
-msg.content     # => "I'm doing well, thank you!"
-msg.tool_calls  # => []
+msg.role         # => :assistant
+msg.content      # => "I'm doing well, thank you!"
+msg.tool_calls   # => []
+msg.token_usage  # => nil or Riffer::TokenUsage
 
 # Response with tool calls
 msg = Riffer::Messages::Assistant.new("", tool_calls: [
@@ -45,6 +46,13 @@ msg = Riffer::Messages::Assistant.new("", tool_calls: [
 ])
 msg.tool_calls  # => [{id: "call_123", ...}]
 msg.to_h        # => {role: "assistant", content: "", tool_calls: [...]}
+
+# Accessing token usage data (when available from provider)
+if msg.token_usage
+  puts "Input tokens: #{msg.token_usage.input_tokens}"
+  puts "Output tokens: #{msg.token_usage.output_tokens}"
+  puts "Total tokens: #{msg.token_usage.total_tokens}"
+end
 ```
 
 ### Tool

data/docs/06_STREAM_EVENTS.md

@@ -109,6 +109,22 @@ event.role     # => "assistant"
 event.content  # => "Let me think about this step by step..."
 ```
 
+### TokenUsageDone
+
+Emitted when token usage data is available at the end of a response:
+
+```ruby
+event = Riffer::StreamEvents::TokenUsageDone.new(token_usage: token_usage)
+event.role                          # => :assistant
+event.token_usage                   # => Riffer::TokenUsage
+event.token_usage.input_tokens      # => 100
+event.token_usage.output_tokens     # => 50
+event.token_usage.total_tokens      # => 150
+event.to_h                          # => {role: :assistant, token_usage: {input_tokens: 100, output_tokens: 50}}
+```
+
+Use this to track token consumption in real-time during streaming.
+
 ## Streaming with Tools
 
 When an agent uses tools during streaming, the flow is:

data/lib/riffer/agent.rb

@@ -101,6 +101,20 @@ class Riffer::Agent
     def all
       subclasses
     end
+
+    # Generates a response using a new agent instance.
+    #
+    # See #generate for parameters and return value.
+    def generate(...)
+      new.generate(...)
+    end
+
+    # Streams a response using a new agent instance.
+    #
+    # See #stream for parameters and return value.
+    def stream(...)
+      new.stream(...)
+    end
   end
 
   # The message history for the agent.
@@ -108,6 +122,11 @@ class Riffer::Agent
   # Returns Array of Riffer::Messages::Base.
   attr_reader :messages
 
+  # Cumulative token usage across all LLM calls.
+  #
+  # Returns Riffer::TokenUsage or nil.
+  attr_reader :token_usage
+
   # Initializes a new agent.
   #
   # Raises Riffer::ArgumentError if the configured model string is invalid
@@ -115,6 +134,7 @@ class Riffer::Agent
   def initialize
     @messages = []
     @message_callbacks = []
+    @token_usage = nil
     @model_string = self.class.model
     @instructions_text = self.class.instructions
 
@@ -140,6 +160,7 @@ class Riffer::Agent
     loop do
       response = call_llm
       add_message(response)
+      track_token_usage(response.token_usage)
 
       break unless has_tool_calls?(response)
 
@@ -164,6 +185,7 @@ class Riffer::Agent
       loop do
         accumulated_content = ""
         accumulated_tool_calls = []
+        accumulated_token_usage = nil
         current_tool_call = nil
 
         call_llm_stream.each do |event|
@@ -186,11 +208,18 @@ class Riffer::Agent
               arguments: event.arguments
             }
             current_tool_call = nil
+          when Riffer::StreamEvents::TokenUsageDone
+            accumulated_token_usage = event.token_usage
           end
         end
 
-        response = Riffer::Messages::Assistant.new(accumulated_content, tool_calls: accumulated_tool_calls)
+        response = Riffer::Messages::Assistant.new(
+          accumulated_content,
+          tool_calls: accumulated_tool_calls,
+          token_usage: accumulated_token_usage
+        )
         add_message(response)
+        track_token_usage(accumulated_token_usage)
 
         break unless has_tool_calls?(response)
 
@@ -219,6 +248,12 @@ class Riffer::Agent
     @message_callbacks.each { |callback| callback.call(message) }
   end
 
+  def track_token_usage(usage)
+    return unless usage
+
+    @token_usage = @token_usage ? @token_usage + usage : usage
+  end
+
   def initialize_messages(prompt_or_messages)
     @messages = []
     @messages << Riffer::Messages::System.new(@instructions_text) if @instructions_text

data/lib/riffer/messages/assistant.rb

@@ -17,13 +17,20 @@ class Riffer::Messages::Assistant < Riffer::Messages::Base
   # Returns Array of Hash.
   attr_reader :tool_calls
 
+  # Token usage data for this response.
+  #
+  # Returns Riffer::TokenUsage or nil.
+  attr_reader :token_usage
+
   # Creates a new assistant message.
   #
   # content:: String - the message content
   # tool_calls:: Array of Hash - optional tool calls
-  def initialize(content, tool_calls: [])
+  # token_usage:: Riffer::TokenUsage or nil - optional token usage data
+  def initialize(content, tool_calls: [], token_usage: nil)
     super(content)
     @tool_calls = tool_calls
+    @token_usage = token_usage
   end
 
   # Returns :assistant.
@@ -33,10 +40,11 @@ class Riffer::Messages::Assistant < Riffer::Messages::Base
 
   # Converts the message to a hash.
   #
-  # Returns Hash with +:role+, +:content+, and optionally +:tool_calls+.
+  # Returns Hash with +:role+, +:content+, and optionally +:tool_calls+ and +:token_usage+.
   def to_h
     hash = {role: role, content: content}
     hash[:tool_calls] = tool_calls unless tool_calls.empty?
+    hash[:token_usage] = token_usage.to_h if token_usage
     hash
   end
 end

data/lib/riffer/providers/amazon_bedrock.rb

@@ -51,7 +51,7 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
     end
 
     response = @client.converse(**params)
-    extract_assistant_message(response)
+    extract_assistant_message(response, extract_token_usage(response))
   end
 
   def perform_stream_text(messages, model:, **options)
@@ -120,6 +120,20 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
         stream.on_message_stop_event do |_event|
           yielder << Riffer::StreamEvents::TextDone.new(accumulated_text)
         end
+
+        stream.on_metadata_event do |event|
+          if event.usage
+            usage = event.usage
+            yielder << Riffer::StreamEvents::TokenUsageDone.new(
+              token_usage: Riffer::TokenUsage.new(
+                input_tokens: usage.input_tokens,
+                output_tokens: usage.output_tokens,
+                cache_creation_tokens: usage.cache_write_input_tokens,
+                cache_read_tokens: usage.cache_read_input_tokens
+              )
+            )
+          end
+        end
       end
     end
   end
@@ -185,7 +199,19 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
     arguments.is_a?(String) ? JSON.parse(arguments) : arguments
   end
 
-  def extract_assistant_message(response)
+  def extract_token_usage(response)
+    usage = response.usage
+    return nil unless usage
+
+    Riffer::TokenUsage.new(
+      input_tokens: usage.input_tokens,
+      output_tokens: usage.output_tokens,
+      cache_creation_tokens: usage.cache_write_input_tokens,
+      cache_read_tokens: usage.cache_read_input_tokens
+    )
+  end
+
+  def extract_assistant_message(response, token_usage = nil)
     output = response.output
     raise Riffer::Error, "No output returned from Bedrock API" if output.nil? || output.message.nil?
 
@@ -212,7 +238,7 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
       raise Riffer::Error, "No content returned from Bedrock API"
     end
 
-    Riffer::Messages::Assistant.new(text_content, tool_calls: tool_calls)
+    Riffer::Messages::Assistant.new(text_content, tool_calls: tool_calls, token_usage: token_usage)
   end
 
   def convert_tool_to_bedrock_format(tool)

data/lib/riffer/providers/anthropic.rb

@@ -42,7 +42,7 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
     end
 
     response = @client.messages.create(**params)
-    extract_assistant_message(response)
+    extract_assistant_message(response, extract_token_usage(response))
   end
 
   def perform_stream_text(messages, model:, **options)
@@ -114,6 +114,18 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
 
         when Anthropic::Streaming::MessageStopEvent
           yielder << Riffer::StreamEvents::TextDone.new(accumulated_text)
+          # Get final usage from accumulated message
+          final_message = stream.accumulated_message
+          if final_message&.usage
+            usage = final_message.usage
+            stream_token_usage = Riffer::TokenUsage.new(
+              input_tokens: usage.input_tokens,
+              output_tokens: usage.output_tokens,
+              cache_creation_tokens: usage.cache_creation_input_tokens,
+              cache_read_tokens: usage.cache_read_input_tokens
+            )
+            yielder << Riffer::StreamEvents::TokenUsageDone.new(token_usage: stream_token_usage)
+          end
         end
       end
     end
@@ -170,7 +182,19 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
     arguments.is_a?(String) ? JSON.parse(arguments) : arguments
   end
 
-  def extract_assistant_message(response)
+  def extract_token_usage(response)
+    usage = response.usage
+    return nil unless usage
+
+    Riffer::TokenUsage.new(
+      input_tokens: usage.input_tokens,
+      output_tokens: usage.output_tokens,
+      cache_creation_tokens: usage.cache_creation_input_tokens,
+      cache_read_tokens: usage.cache_read_input_tokens
+    )
+  end
+
+  def extract_assistant_message(response, token_usage = nil)
     content_blocks = response.content
     raise Riffer::Error, "No content returned from Anthropic API" if content_blocks.nil? || content_blocks.empty?
 
@@ -196,7 +220,7 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
       raise Riffer::Error, "No content returned from Anthropic API"
     end
 
-    Riffer::Messages::Assistant.new(text_content, tool_calls: tool_calls)
+    Riffer::Messages::Assistant.new(text_content, tool_calls: tool_calls, token_usage: token_usage)
   end
 
   def convert_tool_to_anthropic_format(tool)

data/lib/riffer/providers/open_ai.rb

@@ -22,7 +22,7 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
     params = build_request_params(messages, model, options)
     response = @client.responses.create(params)
 
-    extract_assistant_message(response.output)
+    extract_assistant_message(response.output, extract_token_usage(response))
   end
 
   def perform_stream_text(messages, model:, **options)
@@ -93,7 +93,17 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
     end
   end
 
-  def extract_assistant_message(output_items)
+  def extract_token_usage(response)
+    usage = response.usage
+    return nil unless usage
+
+    Riffer::TokenUsage.new(
+      input_tokens: usage.input_tokens,
+      output_tokens: usage.output_tokens
+    )
+  end
+
+  def extract_assistant_message(output_items, token_usage = nil)
     text_content = ""
     tool_calls = []
 
@@ -116,7 +126,7 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
       raise Riffer::Error, "No output returned from OpenAI API"
     end
 
-    Riffer::Messages::Assistant.new(text_content, tool_calls: tool_calls)
+    Riffer::Messages::Assistant.new(text_content, tool_calls: tool_calls, token_usage: token_usage)
   end
 
   def process_stream_events(stream, yielder)
@@ -167,6 +177,16 @@ class Riffer::Providers::OpenAI < Riffer::Providers::Base
         name: tracked[:name],
         arguments: event.arguments
       )
+    when :"response.completed"
+      usage = event.response&.usage
+      if usage
+        Riffer::StreamEvents::TokenUsageDone.new(
+          token_usage: Riffer::TokenUsage.new(
+            input_tokens: usage.input_tokens,
+            output_tokens: usage.output_tokens
+          )
+        )
+      end
     end
   end
 

data/lib/riffer/providers/test.rb

@@ -27,14 +27,15 @@ class Riffer::Providers::Test < Riffer::Providers::Base
   #
   # content:: String - the response content
   # tool_calls:: Array of Hash - optional tool calls to include
+  # token_usage:: Riffer::TokenUsage or nil - optional token usage data to include
   #
   # Returns void.
   #
   #   provider.stub_response("Hello")
   #   provider.stub_response("", tool_calls: [{name: "my_tool", arguments: '{"key":"value"}'}])
-  #   provider.stub_response("Final response")
+  #   provider.stub_response("Final response", token_usage: Riffer::TokenUsage.new(input_tokens: 10, output_tokens: 5))
   #
-  def stub_response(content, tool_calls: [])
+  def stub_response(content, tool_calls: [], token_usage: nil)
     formatted_tool_calls = tool_calls.map.with_index do |tc, idx|
       {
         id: tc[:id] || "test_id_#{idx}",
@@ -43,7 +44,7 @@ class Riffer::Providers::Test < Riffer::Providers::Base
         arguments: tc[:arguments].is_a?(String) ? tc[:arguments] : tc[:arguments].to_json
       }
     end
-    @stubbed_responses << {role: "assistant", content: content, tool_calls: formatted_tool_calls}
+    @stubbed_responses << {role: "assistant", content: content, tool_calls: formatted_tool_calls, token_usage: token_usage}
   end
 
   # Clears all stubbed responses.
@@ -72,7 +73,11 @@ class Riffer::Providers::Test < Riffer::Providers::Base
     response = next_response
 
     if response.is_a?(Hash)
-      Riffer::Messages::Assistant.new(response[:content], tool_calls: response[:tool_calls] || [])
+      Riffer::Messages::Assistant.new(
+        response[:content],
+        tool_calls: response[:tool_calls] || [],
+        token_usage: response[:token_usage]
+      )
     else
       response
     end
@@ -84,6 +89,7 @@ class Riffer::Providers::Test < Riffer::Providers::Base
     Enumerator.new do |yielder|
       full_content = response[:content] || ""
       tool_calls = response[:tool_calls] || []
+      token_usage = response[:token_usage]
 
       unless full_content.empty?
         content_parts = full_content.split(". ").map { |part| part + (part.end_with?(".") ? "" : ".") }
@@ -107,6 +113,7 @@ class Riffer::Providers::Test < Riffer::Providers::Base
       end
 
       yielder << Riffer::StreamEvents::TextDone.new(full_content)
+      yielder << Riffer::StreamEvents::TokenUsageDone.new(token_usage: token_usage) if token_usage
     end
   end
 end

data/lib/riffer/stream_events/token_usage_done.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# Represents completion of token usage tracking during streaming.
+#
+# Emitted when the LLM has finished and token usage data is available.
+#
+#   event.token_usage.input_tokens   # => 100
+#   event.token_usage.output_tokens  # => 50
+#   event.token_usage.total_tokens   # => 150
+#
+class Riffer::StreamEvents::TokenUsageDone < Riffer::StreamEvents::Base
+  # The token usage data for this response.
+  #
+  # Returns Riffer::TokenUsage.
+  attr_reader :token_usage
+
+  # Creates a new token usage done event.
+  #
+  # token_usage:: Riffer::TokenUsage - the token usage data
+  # role:: Symbol - the message role (defaults to :assistant)
+  def initialize(token_usage:, role: :assistant)
+    super(role: role)
+    @token_usage = token_usage
+  end
+
+  # Converts the event to a hash.
+  #
+  # Returns Hash with +:role+ and +:token_usage+ keys.
+  def to_h
+    {role: @role, token_usage: @token_usage.to_h}
+  end
+end

data/lib/riffer/token_usage.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# Represents token usage data from an LLM API call.
+#
+# Tracks input tokens, output tokens, and optional cache statistics.
+#
+#   token_usage = Riffer::TokenUsage.new(input_tokens: 100, output_tokens: 50)
+#   token_usage.total_tokens  # => 150
+#
+#   combined = token_usage1 + token_usage2  # Combine multiple token usage objects
+#
+class Riffer::TokenUsage
+  # Number of tokens in the input/prompt.
+  #
+  # Returns Integer.
+  attr_reader :input_tokens
+
+  # Number of tokens in the output/response.
+  #
+  # Returns Integer.
+  attr_reader :output_tokens
+
+  # Number of tokens written to cache (Anthropic-specific).
+  #
+  # Returns Integer or nil.
+  attr_reader :cache_creation_tokens
+
+  # Number of tokens read from cache (Anthropic-specific).
+  #
+  # Returns Integer or nil.
+  attr_reader :cache_read_tokens
+
+  # Creates a new TokenUsage instance.
+  #
+  # input_tokens:: Integer - number of input tokens
+  # output_tokens:: Integer - number of output tokens
+  # cache_creation_tokens:: Integer or nil - tokens written to cache
+  # cache_read_tokens:: Integer or nil - tokens read from cache
+  def initialize(input_tokens:, output_tokens:, cache_creation_tokens: nil, cache_read_tokens: nil)
+    @input_tokens = input_tokens
+    @output_tokens = output_tokens
+    @cache_creation_tokens = cache_creation_tokens
+    @cache_read_tokens = cache_read_tokens
+  end
+
+  # Returns the total number of tokens (input + output).
+  #
+  # Returns Integer.
+  def total_tokens
+    input_tokens + output_tokens
+  end
+
+  # Combines two TokenUsage objects for cumulative tracking.
+  #
+  # other:: Riffer::TokenUsage - another token usage object to combine with
+  #
+  # Returns Riffer::TokenUsage - a new TokenUsage with summed values.
+  def +(other)
+    Riffer::TokenUsage.new(
+      input_tokens: input_tokens + other.input_tokens,
+      output_tokens: output_tokens + other.output_tokens,
+      cache_creation_tokens: add_nullable(cache_creation_tokens, other.cache_creation_tokens),
+      cache_read_tokens: add_nullable(cache_read_tokens, other.cache_read_tokens)
+    )
+  end
+
+  # Converts the token usage to a hash representation.
+  #
+  # Cache tokens are omitted if nil.
+  #
+  # Returns Hash.
+  def to_h
+    hash = {input_tokens: input_tokens, output_tokens: output_tokens}
+    hash[:cache_creation_tokens] = cache_creation_tokens if cache_creation_tokens
+    hash[:cache_read_tokens] = cache_read_tokens if cache_read_tokens
+    hash
+  end
+
+  private
+
+  def add_nullable(a, b)
+    return nil if a.nil? && b.nil?
+    (a || 0) + (b || 0)
+  end
+end

data/lib/riffer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Riffer
-  VERSION = "0.10.0"
+  VERSION = "0.11.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riffer
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Jake Bottrall
@@ -35,28 +35,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.16.3
+        version: 1.17.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.16.3
+        version: 1.17.0
 - !ruby/object:Gem::Dependency
   name: aws-sdk-bedrockruntime
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.42'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '1.42'
 - !ruby/object:Gem::Dependency
   name: openai
   requirement: !ruby/object:Gem::Requirement
@@ -208,8 +208,10 @@ files:
 - lib/riffer/stream_events/reasoning_done.rb
 - lib/riffer/stream_events/text_delta.rb
 - lib/riffer/stream_events/text_done.rb
+- lib/riffer/stream_events/token_usage_done.rb
 - lib/riffer/stream_events/tool_call_delta.rb
 - lib/riffer/stream_events/tool_call_done.rb
+- lib/riffer/token_usage.rb
 - lib/riffer/tool.rb
 - lib/riffer/tools.rb
 - lib/riffer/tools/param.rb