riffer 0.38.0 → 0.39.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 201c994ac795b1563165552d686a38b103b83f718ceae14b102213ecb17984fd
-  data.tar.gz: 933ede064f5446e7634a446c9cf8ad502c99728ee87f18498fdb564303f2dce1
+  metadata.gz: b1bf92e3bef065a4c07aadb273a7f6770b711c0f15f268726133c841cb3fd510
+  data.tar.gz: d7361c029b98ca819932e2c3d2d53113710bb434ad60092ee0578179fa844c5e
 SHA512:
-  metadata.gz: 064e68be4a2c9916e6a33fed5952501722434396c82eed7da754cadaef509ecce764b67297f61bc1dca5e0cef1ec4447bb99013fb6cc4ac70dc74c274ecc746a
-  data.tar.gz: fbeda57bbc9611d9f1be65f01560faf26e93c7d723e2e9116e6fb0d7c1f7b005488fd123c14f3917c4e73345b6554e7b10e8a7b104fe6bb5b65cf547f86de859
+  metadata.gz: 7f503377743f6629a1423234afb158570dc33ee225c82c0bc46e28938a839fe25b5bdfad6f61da274a8bf81e1e8dd6c505ad826593c5eb269251d47667fe9d7c
+  data.tar.gz: eddabf85e5416c777c3a9a441ce99cd1cb902ec1c339fa7338890ae8cb7e78c5e78628e1b886aea44cdc6228b99299fa3983816e10075d8c28b59229e4c0b376

data/.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.38.0"
+  ".": "0.39.0"
 }

data/CHANGELOG.md

@@ -5,6 +5,20 @@ 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.39.0](https://github.com/janeapp/riffer/compare/riffer/v0.38.1...riffer/v0.39.0) (2026-07-29)
+
+
+### Features
+
+* **evals:** expose token usage on evaluation results ([#380](https://github.com/janeapp/riffer/issues/380)) ([32d576e](https://github.com/janeapp/riffer/commit/32d576e492809845c36f44ebf37de3af3b6785b0))
+
+## [0.38.1](https://github.com/janeapp/riffer/compare/riffer/v0.38.0...riffer/v0.38.1) (2026-07-29)
+
+
+### Performance Improvements
+
+* avoid O(n^2) text accumulation in streaming providers ([#378](https://github.com/janeapp/riffer/issues/378)) ([d344fa7](https://github.com/janeapp/riffer/commit/d344fa7122492d14ee1c91c0be3a88501170e255))
+
 ## [0.38.0](https://github.com/janeapp/riffer/compare/riffer/v0.37.1...riffer/v0.38.0) (2026-07-21)
 
 

data/docs/11_EVALS.md

@@ -108,9 +108,11 @@ Per-scenario `context` overrides the top-level value. Scenarios without their ow
 The runner returns a `Riffer::Evals::RunResult`:
 
 ```ruby
-result.scores             # => { EvaluatorClass => avg_score } across all scenarios
-result.scenario_results   # => Array of ScenarioResult objects
-result.to_h               # => Hash representation
+result.scores                  # => { EvaluatorClass => avg_score } across all scenarios
+result.scenario_results        # => Array of ScenarioResult objects
+result.token_usage             # => TokenUsage the agent under test spent, summed across scenarios (nil if none reported)
+result.evaluator_token_usage   # => TokenUsage the judges spent, summed across scenarios (nil if no judge ran)
+result.to_h                    # => Hash representation
 ```
 
 ### ScenarioResult
@@ -119,13 +121,15 @@ Each scenario produces a `Riffer::Evals::ScenarioResult`:
 
 ```ruby
 scenario = result.scenario_results.first
-scenario.input        # => "What is the capital of France?"
-scenario.output       # => "The capital of France is Paris."
-scenario.ground_truth # => "Paris"
-scenario.scores       # => { EvaluatorClass => score } for this scenario
-scenario.results      # => Array of Result objects
-scenario.messages     # => Array of Message objects (system, user, assistant, tool)
-scenario.to_h         # => Hash representation
+scenario.input                  # => "What is the capital of France?"
+scenario.output                 # => "The capital of France is Paris."
+scenario.ground_truth           # => "Paris"
+scenario.scores                 # => { EvaluatorClass => score } for this scenario
+scenario.results                # => Array of Result objects
+scenario.messages               # => Array of Message objects (system, user, assistant, tool)
+scenario.token_usage            # => TokenUsage the agent under test spent on this scenario (nil if not reported)
+scenario.evaluator_token_usage  # => TokenUsage the judges spent on this scenario (nil if no judge ran)
+scenario.to_h                   # => Hash representation
 ```
 
 ### Result
@@ -138,8 +142,13 @@ r.evaluator        # => AnswerRelevancyEvaluator
 r.score            # => 0.92
 r.reason           # => "The response directly addresses..."
 r.higher_is_better # => true
+r.token_usage      # => TokenUsage for the judge call (nil for rule-based evaluators)
 ```
 
+`token_usage` is a `Riffer::Providers::TokenUsage`, the same type the agent exposes on `Agent::Response`, so eval usage accumulates with the `+` operator just like agent usage. On a `Result` it's populated for LLM-as-judge evaluators and `nil` for rule-based ones that never call an LLM.
+
+`ScenarioResult` and `RunResult` keep the two sources separate rather than exposing a single total: `token_usage` is what the agent under test spent generating the output, and `evaluator_token_usage` is what the judges spent scoring it. Add them yourself if you want a combined figure.
+
 ## Defining Custom Evaluators
 
 Create evaluators by subclassing `Riffer::Evals::Evaluator`. The simplest approach uses the `instructions` DSL — the base class handles calling the judge automatically:
@@ -190,7 +199,7 @@ Instance methods:
 
 - `evaluate(input:, output:, ground_truth:, messages:)` - Override for custom logic; default calls judge with `instructions`
 - `judge` - Returns a Judge instance for LLM-as-judge calls
-- `result(score:, reason:, metadata:)` - Helper to build Result objects
+- `result(score:, reason:, metadata:, token_usage:)` - Helper to build Result objects
 
 ### Advanced: Custom Evaluate Override
 

data/lib/riffer/agent/run.rb

@@ -121,7 +121,7 @@ module Riffer::Agent::Run
   #--
   #: (Riffer::Agent, Enumerator::Yielder, ?Hash[String, String]) -> Riffer::Messages::Assistant
   def accumulate_streamed_response(agent, stream_yielder, tags = {})
-    accumulated_content = ""
+    accumulated_content = +""
     accumulated_tool_calls = [] #: Array[Riffer::Messages::Assistant::ToolCall]
     accumulated_token_usage = nil #: Riffer::Providers::TokenUsage?
     accumulated_finish_reason = nil #: Symbol?
@@ -131,9 +131,13 @@ module Riffer::Agent::Run
 
       case event
       when Riffer::StreamEvents::TextDelta
-        accumulated_content += event.content
+        # Append in place rather than += (which reallocates and copies the whole
+        # buffer per delta, O(n^2) over a stream). accumulated_content stays an
+        # owned buffer; replace (not =) on TextDone keeps it that way so a later
+        # delta's << can never mutate the string held by a TextDone event.
+        accumulated_content << event.content
       when Riffer::StreamEvents::TextDone
-        accumulated_content = event.content
+        accumulated_content.replace(event.content)
       when Riffer::StreamEvents::ToolCallDone
         accumulated_tool_calls << Riffer::Messages::Assistant::ToolCall.new(
           call_id: event.call_id,

data/lib/riffer/evals/evaluator.rb

@@ -66,7 +66,7 @@ class Riffer::Evals::Evaluator
       ground_truth: ground_truth
     )
 
-    result(score: evaluation[:score], reason: evaluation[:reason])
+    result(score: evaluation[:score], reason: evaluation[:reason], token_usage: evaluation[:token_usage])
   end
 
   private
@@ -105,14 +105,15 @@ class Riffer::Evals::Evaluator
 
   # Builds a Result for this evaluator.
   #--
-  #: (score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped]) -> Riffer::Evals::Result
-  def result(score:, reason: nil, metadata: {})
+  #: (score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped], ?token_usage: Riffer::Providers::TokenUsage?) -> Riffer::Evals::Result
+  def result(score:, reason: nil, metadata: {}, token_usage: nil)
     Riffer::Evals::Result.new(
       evaluator: self.class,
       score: score,
       reason: reason,
       metadata: metadata,
-      higher_is_better: self.class.higher_is_better
+      higher_is_better: self.class.higher_is_better,
+      token_usage: token_usage
     )
   end
 end

data/lib/riffer/evals/evaluator_runner.rb

@@ -62,6 +62,7 @@ module Riffer::Evals::EvaluatorRunner
     response = agent.generate(input, context: resolved_context)
     output = response.content
     messages = response.messages
+    token_usage = response.token_usage
 
     results = evaluators.map do |evaluator_class|
       evaluator_class.new.evaluate(input: input, output: output, ground_truth: ground_truth, messages: messages)
@@ -72,7 +73,8 @@ module Riffer::Evals::EvaluatorRunner
       output: output,
       ground_truth: ground_truth,
       results: results,
-      messages: messages
+      messages: messages,
+      token_usage: token_usage
     )
   end
 end

data/lib/riffer/evals/judge.rb

@@ -121,7 +121,8 @@ class Riffer::Evals::Judge
 
     {
       score: score.to_f,
-      reason: reason
+      reason: reason,
+      token_usage: response.token_usage
     }
   rescue JSON::ParserError => e
     raise Riffer::Error, "Invalid judge response: #{e.message}"

data/lib/riffer/evals/result.rb

@@ -18,16 +18,21 @@ class Riffer::Evals::Result
   # Whether higher scores are better for this evaluator.
   attr_reader :higher_is_better #: bool
 
+  # Token usage for the judge call that produced this result, when the
+  # evaluator used an LLM. Nil for rule-based evaluators.
+  attr_reader :token_usage #: Riffer::Providers::TokenUsage?
+
   # Raises Riffer::ArgumentError if +score+ is not between 0.0 and 1.0.
   #--
-  #: (evaluator: singleton(Riffer::Evals::Evaluator), score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped], ?higher_is_better: bool) -> void
-  def initialize(evaluator:, score:, reason: nil, metadata: {}, higher_is_better: true)
+  #: (evaluator: singleton(Riffer::Evals::Evaluator), score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped], ?higher_is_better: bool, ?token_usage: Riffer::Providers::TokenUsage?) -> void
+  def initialize(evaluator:, score:, reason: nil, metadata: {}, higher_is_better: true, token_usage: nil)
     @evaluator = evaluator
     @score = score.to_f
     validate_score!
     @reason = reason
     @metadata = metadata
     @higher_is_better = higher_is_better
+    @token_usage = token_usage
   end
 
   # Returns a hash representation of the result.
@@ -40,7 +45,8 @@ class Riffer::Evals::Result
       score: score,
       reason: reason,
       metadata: metadata,
-      higher_is_better: higher_is_better
+      higher_is_better: higher_is_better,
+      token_usage: token_usage&.to_h
     }
   end
 

data/lib/riffer/evals/run_result.rb

@@ -35,6 +35,24 @@ class Riffer::Evals::RunResult
     end
   end
 
+  # Returns the summed token usage the agents under test spent across every
+  # scenario, or nil when none reported usage.
+  #
+  #--
+  #: () -> Riffer::Providers::TokenUsage?
+  def token_usage
+    scenario_results.map(&:token_usage).compact.reduce(:+)
+  end
+
+  # Returns the summed token usage across every scenario's LLM-as-judge
+  # evaluators, or nil when none reported usage.
+  #
+  #--
+  #: () -> Riffer::Providers::TokenUsage?
+  def evaluator_token_usage
+    scenario_results.map(&:evaluator_token_usage).compact.reduce(:+)
+  end
+
   # Returns a hash representation of the run result.
   #
   #--
@@ -42,7 +60,9 @@ class Riffer::Evals::RunResult
   def to_h
     {
       scores: scores.transform_keys(&:name),
-      scenario_results: scenario_results.map(&:to_h)
+      scenario_results: scenario_results.map(&:to_h),
+      token_usage: token_usage&.to_h,
+      evaluator_token_usage: evaluator_token_usage&.to_h
     }
   end
 end

data/lib/riffer/evals/scenario_result.rb

@@ -18,14 +18,18 @@ class Riffer::Evals::ScenarioResult
   # The full message history from the agent conversation.
   attr_reader :messages #: Array[Riffer::Messages::Base]
 
+  # Token usage the agent under test spent generating this scenario's output.
+  attr_reader :token_usage #: Riffer::Providers::TokenUsage?
+
   #--
-  #: (input: String, output: String, ground_truth: String?, results: Array[Riffer::Evals::Result], ?messages: Array[Riffer::Messages::Base]) -> void
-  def initialize(input:, output:, ground_truth:, results:, messages: [])
+  #: (input: String, output: String, ground_truth: String?, results: Array[Riffer::Evals::Result], ?messages: Array[Riffer::Messages::Base], ?token_usage: Riffer::Providers::TokenUsage?) -> void
+  def initialize(input:, output:, ground_truth:, results:, messages: [], token_usage: nil)
     @input = input
     @output = output
     @ground_truth = ground_truth
     @results = results
     @messages = messages
+    @token_usage = token_usage
   end
 
   # Returns scores keyed by evaluator class.
@@ -39,6 +43,15 @@ class Riffer::Evals::ScenarioResult
     end
   end
 
+  # Returns the summed token usage across this scenario's LLM-as-judge
+  # evaluators, or nil when none reported usage.
+  #
+  #--
+  #: () -> Riffer::Providers::TokenUsage?
+  def evaluator_token_usage
+    results.map(&:token_usage).compact.reduce(:+)
+  end
+
   # Returns a hash representation of the scenario result.
   #
   #--
@@ -50,7 +63,9 @@ class Riffer::Evals::ScenarioResult
       ground_truth: ground_truth,
       scores: scores.transform_keys(&:name),
       results: results.map(&:to_h),
-      messages: messages.map(&:to_h)
+      messages: messages.map(&:to_h),
+      token_usage: token_usage&.to_h,
+      evaluator_token_usage: evaluator_token_usage&.to_h
     }
   end
 end

data/lib/riffer/providers/amazon_bedrock.rb

@@ -267,7 +267,7 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
     state[:tool_call] = {
       id: typed_event.start.tool_use.tool_use_id,
       name: decode_tool_name(typed_event.start.tool_use.name, tools: @current_tools),
-      arguments: ""
+      arguments: +""
     }
   end
 
@@ -276,8 +276,13 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
   def handle_content_block_delta_text_delta(event, state:, yielder:)
     typed_event = event #: Aws::BedrockRuntime::Types::ContentBlockDeltaEvent
     delta_text = typed_event.delta.text
-    state[:text] ||= ""
-    state[:text] += delta_text
+    # Mutating append: += would reallocate and copy the whole accumulated
+    # buffer on every delta (O(n^2) per content block). state[:text] is handed
+    # off to TextDone and then cleared on block stop, so nothing reads the
+    # pre-append string, making in-place mutation safe. Seed with an unfrozen
+    # String (+"") so << does not raise under frozen_string_literal.
+    state[:text] ||= +""
+    state[:text] << delta_text
     yielder << Riffer::StreamEvents::TextDelta.new(delta_text)
   end
 
@@ -287,7 +292,7 @@ class Riffer::Providers::AmazonBedrock < Riffer::Providers::Base
     typed_event = event #: Aws::BedrockRuntime::Types::ContentBlockDeltaEvent
     input_delta = typed_event.delta.tool_use.input
 
-    state[:tool_call][:arguments] += input_delta
+    state[:tool_call][:arguments] << input_delta
 
     yielder << Riffer::StreamEvents::ToolCallDelta.new(
       item_id: state[:tool_call][:id],

data/lib/riffer/providers/anthropic.rb

@@ -233,7 +233,7 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
     content_block = event.content_block
     if content_block.type.to_s == "server_tool_use" && content_block.name.to_s == "web_search"
       state[:web_search_index] = event.index
-      state[:web_search_json] = ""
+      state[:web_search_json] = +""
     end
   end
 
@@ -243,22 +243,27 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
     return unless state[:web_search_index] == event.index
 
     delta = event.delta
-    state[:web_search_json] += delta.partial_json if delta.respond_to?(:partial_json)
+    state[:web_search_json] << delta.partial_json if delta.respond_to?(:partial_json)
   end
 
   #--
   #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_text_event(event, state:, yielder:)
-    state[:text] ||= ""
-    state[:text] += event.text
+    # Mutating append instead of += to avoid reallocating and copying the whole
+    # accumulated buffer on every delta (O(n^2) per content block). The buffer
+    # is handed to TextDone and cleared on block stop, so no reader observes the
+    # pre-append string. Seed with an unfrozen String so << is legal under
+    # frozen_string_literal.
+    state[:text] ||= +""
+    state[:text] << event.text
     yielder << Riffer::StreamEvents::TextDelta.new(event.text)
   end
 
   #--
   #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_thinking_event(event, state:, yielder:)
-    state[:reasoning] ||= ""
-    state[:reasoning] += event.thinking
+    state[:reasoning] ||= +""
+    state[:reasoning] << event.thinking
     yielder << Riffer::StreamEvents::ReasoningDelta.new(event.thinking)
   end
 
@@ -266,9 +271,9 @@ class Riffer::Providers::Anthropic < Riffer::Providers::Base
   #: (untyped, state: Hash[Symbol, untyped], yielder: Riffer::Providers::_EventSink) -> void
   def handle_input_json_event(event, state:, yielder:)
     if state[:tool_call].nil?
-      state[:tool_call] = {id: nil, name: nil, arguments: ""}
+      state[:tool_call] = {id: nil, name: nil, arguments: +""}
     end
-    state[:tool_call][:arguments] += event.partial_json
+    state[:tool_call][:arguments] << event.partial_json
     yielder << Riffer::StreamEvents::ToolCallDelta.new(
       item_id: state[:tool_call][:id] || "pending",
       name: state[:tool_call][:name],

data/lib/riffer/version.rb

@@ -2,5 +2,5 @@
 # rbs_inline: enabled
 
 module Riffer
-  VERSION = "0.38.0" #: String
+  VERSION = "0.39.0" #: String
 end

data/sig/generated/riffer/evals/evaluator.rbs

@@ -57,6 +57,6 @@ class Riffer::Evals::Evaluator
 
   # Builds a Result for this evaluator.
   # --
-  # : (score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped]) -> Riffer::Evals::Result
-  def result: (score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped]) -> Riffer::Evals::Result
+  # : (score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped], ?token_usage: Riffer::Providers::TokenUsage?) -> Riffer::Evals::Result
+  def result: (score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped], ?token_usage: Riffer::Providers::TokenUsage?) -> Riffer::Evals::Result
 end

data/sig/generated/riffer/evals/result.rbs

@@ -17,10 +17,14 @@ class Riffer::Evals::Result
   # Whether higher scores are better for this evaluator.
   attr_reader higher_is_better: bool
 
+  # Token usage for the judge call that produced this result, when the
+  # evaluator used an LLM. Nil for rule-based evaluators.
+  attr_reader token_usage: Riffer::Providers::TokenUsage?
+
   # Raises Riffer::ArgumentError if +score+ is not between 0.0 and 1.0.
   # --
-  # : (evaluator: singleton(Riffer::Evals::Evaluator), score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped], ?higher_is_better: bool) -> void
-  def initialize: (evaluator: singleton(Riffer::Evals::Evaluator), score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped], ?higher_is_better: bool) -> void
+  # : (evaluator: singleton(Riffer::Evals::Evaluator), score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped], ?higher_is_better: bool, ?token_usage: Riffer::Providers::TokenUsage?) -> void
+  def initialize: (evaluator: singleton(Riffer::Evals::Evaluator), score: Float, ?reason: String?, ?metadata: Hash[Symbol, untyped], ?higher_is_better: bool, ?token_usage: Riffer::Providers::TokenUsage?) -> void
 
   # Returns a hash representation of the result.
   #

data/sig/generated/riffer/evals/run_result.rbs

@@ -15,6 +15,20 @@ class Riffer::Evals::RunResult
   # : () -> Hash[singleton(Riffer::Evals::Evaluator), Float]
   def scores: () -> Hash[singleton(Riffer::Evals::Evaluator), Float]
 
+  # Returns the summed token usage the agents under test spent across every
+  # scenario, or nil when none reported usage.
+  #
+  # --
+  # : () -> Riffer::Providers::TokenUsage?
+  def token_usage: () -> Riffer::Providers::TokenUsage?
+
+  # Returns the summed token usage across every scenario's LLM-as-judge
+  # evaluators, or nil when none reported usage.
+  #
+  # --
+  # : () -> Riffer::Providers::TokenUsage?
+  def evaluator_token_usage: () -> Riffer::Providers::TokenUsage?
+
   # Returns a hash representation of the run result.
   #
   # --

data/sig/generated/riffer/evals/scenario_result.rbs

@@ -17,9 +17,12 @@ class Riffer::Evals::ScenarioResult
   # The full message history from the agent conversation.
   attr_reader messages: Array[Riffer::Messages::Base]
 
+  # Token usage the agent under test spent generating this scenario's output.
+  attr_reader token_usage: Riffer::Providers::TokenUsage?
+
   # --
-  # : (input: String, output: String, ground_truth: String?, results: Array[Riffer::Evals::Result], ?messages: Array[Riffer::Messages::Base]) -> void
-  def initialize: (input: String, output: String, ground_truth: String?, results: Array[Riffer::Evals::Result], ?messages: Array[Riffer::Messages::Base]) -> void
+  # : (input: String, output: String, ground_truth: String?, results: Array[Riffer::Evals::Result], ?messages: Array[Riffer::Messages::Base], ?token_usage: Riffer::Providers::TokenUsage?) -> void
+  def initialize: (input: String, output: String, ground_truth: String?, results: Array[Riffer::Evals::Result], ?messages: Array[Riffer::Messages::Base], ?token_usage: Riffer::Providers::TokenUsage?) -> void
 
   # Returns scores keyed by evaluator class.
   #
@@ -27,6 +30,13 @@ class Riffer::Evals::ScenarioResult
   # : () -> Hash[singleton(Riffer::Evals::Evaluator), Float]
   def scores: () -> Hash[singleton(Riffer::Evals::Evaluator), Float]
 
+  # Returns the summed token usage across this scenario's LLM-as-judge
+  # evaluators, or nil when none reported usage.
+  #
+  # --
+  # : () -> Riffer::Providers::TokenUsage?
+  def evaluator_token_usage: () -> Riffer::Providers::TokenUsage?
+
   # Returns a hash representation of the scenario result.
   #
   # --

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: riffer
 version: !ruby/object:Gem::Version
-  version: 0.38.0
+  version: 0.39.0
 platform: ruby
 authors:
 - Jake Bottrall
@@ -35,14 +35,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.56.0
+        version: 1.59.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.56.0
+        version: 1.59.0
 - !ruby/object:Gem::Dependency
   name: aws-sdk-bedrockruntime
   requirement: !ruby/object:Gem::Requirement
@@ -77,28 +77,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: openai
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.71.0
+        version: 0.72.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.71.0
+        version: 0.72.0
 - !ruby/object:Gem::Dependency
   name: async
   requirement: !ruby/object:Gem::Requirement
@@ -108,7 +108,7 @@ dependencies:
         version: '2.25'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2.43'
+        version: '2.44'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -118,7 +118,7 @@ dependencies:
         version: '2.25'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '2.43'
+        version: '2.44'
 - !ruby/object:Gem::Dependency
   name: io-event
   requirement: !ruby/object:Gem::Requirement