ruby_llm 2.0.0 → 2.1.0

data/lib/ruby_llm/protocols/cohere/batch_requests.rb

@@ -24,11 +24,6 @@ module RubyLLM
 
         def render_batch_request(request, type:)
           body = JSON.parse(JSON.generate(batch_payload(request, except: :model)))
-          if type == 'batch-embed-v2-input' && body['output_dimension']
-            raise ArgumentError,
-                  'Cohere batch datasets currently reject dimensions; omit dimensions to use the model default'
-          end
-
           render_batch_chat(body) if type == 'batch-chat-v2-input'
           allowed = type == 'batch-chat-v2-input' ? CHAT_FIELDS : EMBEDDING_FIELDS
           unsupported = body.keys - allowed

data/lib/ruby_llm/protocols/cohere/batches.rb

@@ -40,13 +40,7 @@ module RubyLLM
           file = datasets.wait_for_validation(data.fetch('output_dataset_id'))
           model = RubyLLM.models.find(data.fetch('model'), provider: @provider.slug, config: @config)
           parser = self.class.new(@provider, model)
-          results = datasets.records(file).map { |row| parse_batch_result(row, parser:, model: model.id) }
-          unless results.map(&:first).uniq.size == results.size
-            raise Error,
-                  'Cohere returned duplicate batch request IDs'
-          end
-
-          results
+          datasets.records(file).map { |row| parse_batch_result(row, parser:, model: model.id) }
         end
 
         private
@@ -84,6 +78,8 @@ module RubyLLM
           return [index, nil, batch_failure(custom_id, row['error'])] if !row['error'].to_s.empty? || !row['body']
 
           body = row.fetch('body')
+          return [index, nil, batch_failure(custom_id, 'generation failed')] if body['finish_reason'] == 'ERROR'
+
           result = if body['embeddings']
                      parser.send(:parse_embedding_response, Response.new(body), model:,
                                                                                 text: shape == 'array' ? [] : nil)

data/lib/ruby_llm/protocols/cohere/chat.rb

@@ -107,6 +107,8 @@ module RubyLLM
         end
 
         def parse_completion_body(data, raw:)
+          raise_failed_generation(nil, response: raw) if data['finish_reason'] == 'ERROR'
+
           message_data = data['message'] || {}
           blocks = Array(message_data['content'])
           content, offsets = extract_text(blocks)
@@ -125,6 +127,12 @@ module RubyLLM
           )
         end
 
+        # Cohere answers a generation that failed on its side with an ERROR
+        # finish reason instead of an error status.
+        def raise_failed_generation(message, response: nil)
+          raise ServerError.new(message || 'The generation failed due to an internal error', response:)
+        end
+
         # Cohere reports what the model processed under tokens and what it
         # charges for under billed_units; the two differ because Cohere does
         # not bill its own preamble.

data/lib/ruby_llm/protocols/cohere/embeddings.rb

@@ -37,11 +37,14 @@ module RubyLLM
         end
 
         def image_embedding_inputs(text, attachments) # :nodoc:
-          raise ArgumentError, 'Cohere Embed v3 accepts text or an image, not both' unless text.nil? || text == ''
-          raise ArgumentError, 'Cohere Embed v3 accepts one image per request' unless attachments.one?
-          raise UnsupportedAttachmentError, attachments.first.mime_type unless attachments.first.image?
+          raise ArgumentError, 'Cohere Embed v3 accepts text or images, not both' unless text.nil? || text == ''
 
-          { images: ["data:#{attachments.first.mime_type};base64,#{attachments.first.encoded}"] }
+          images = attachments.map do |attachment|
+            raise UnsupportedAttachmentError, attachment.mime_type unless attachment.image?
+
+            "data:#{attachment.mime_type};base64,#{attachment.encoded}"
+          end
+          { images: }
         end
 
         def parse_embedding_response(response, model:, text:)

data/lib/ruby_llm/protocols/cohere/media.rb

@@ -11,6 +11,10 @@ module RubyLLM
 
         module_function
 
+        def supported_attachment?(attachment)
+          %i[image text].include?(attachment.type)
+        end
+
         # Cohere user messages accept only text and image_url blocks. Text
         # attachments become citable documents when citations are on, so they
         # are pulled out of the message and left out of the content blocks.
@@ -19,13 +23,13 @@ module RubyLLM
           parts << format_text(content) if content
 
           attachments.each do |attachment|
+            raise UnsupportedAttachmentError, attachment.mime_type unless supported_attachment?(attachment)
+
             case attachment.type
             when :image
               parts << format_image(attachment)
             when :text
               parts << format_text(attachment.for_llm) unless citations
-            else
-              raise UnsupportedAttachmentError, attachment.mime_type
             end
           end
 

data/lib/ruby_llm/protocols/cohere/ocr.rb

@@ -16,7 +16,7 @@ module RubyLLM
           raise UnsupportedAttachmentError, attachment.mime_type unless attachment.image?
           raise ArgumentError, 'Cohere Parse accepts one image; pages must be [0]' unless pages.nil? || pages == [0]
 
-          reference = attachment.url? ? attachment.source.to_s : attachment.for_llm
+          reference = attachment.url_or_data_uri
           {
             model: model,
             document: { type: 'image_url', image_url: reference },

data/lib/ruby_llm/protocols/cohere/streaming.rb

@@ -13,6 +13,7 @@ module RubyLLM
 
         def build_chunk(data)
           type = data['type']
+          raise_failed_generation(data.dig('delta', 'error')) if data.dig('delta', 'finish_reason') == 'ERROR'
           track_content_lengths(data, type)
 
           Chunk.new(

data/lib/ruby_llm/protocols/cohere/tools.rb

@@ -76,6 +76,10 @@ module RubyLLM
           }
         end
 
+        def supported_message_attachment?(message, attachment)
+          message.role == :tool ? attachment.text? : supported_attachment?(attachment)
+        end
+
         # Search results become document content blocks, the shape Cohere
         # cites tool output against. A tool that attaches files sends its
         # text and each attachment as blocks, so the model reads what the
@@ -86,7 +90,7 @@ module RubyLLM
           return msg.content.to_s if msg.attachments.empty?
 
           [Media.format_text(msg.content.to_s)] + msg.attachments.map do |attachment|
-            raise UnsupportedAttachmentError, attachment.mime_type unless attachment.type == :text
+            raise UnsupportedAttachmentError, attachment.mime_type unless supported_message_attachment?(msg, attachment)
 
             Media.format_text(attachment.for_llm)
           end

data/lib/ruby_llm/protocols/cohere.rb

@@ -16,6 +16,7 @@ module RubyLLM
       include Cohere::Streaming
       include Cohere::Tools
       include Cohere::Transcription
+      include ChatCompletions::RequestShapes
     end
   end
 end

data/lib/ruby_llm/protocols/converse/chat.rb

@@ -16,8 +16,6 @@ module RubyLLM
         BEDROCK_INLINE_DOCUMENT_LIMIT = 4_500_000
         PROMPT_CACHE_OPTIONS = %i[ttl].freeze
         COUNT_TOKENS_KEYS = %i[messages system toolConfig additionalModelRequestFields].freeze
-        RANGED_EFFORTS = %w[low medium high].freeze
-        MINIMUM_BUDGET_TOKENS = 1
 
         module_function
 
@@ -124,6 +122,7 @@ module RubyLLM
             output_tokens: usage['outputTokens'],
             cache_read_tokens: usage['cacheReadInputTokens'],
             cache_write_tokens: usage['cacheWriteInputTokens'],
+            cache_write_tokens_by_ttl: cache_write_by_ttl(usage),
             thinking_tokens: reasoning_tokens(usage),
             finish_reason: normalize_finish_reason(data['stopReason']),
             model: data['modelId'] || @model&.id,
@@ -143,6 +142,15 @@ module RubyLLM
           usage['reasoningTokens'] || usage.dig('outputTokensDetails', 'reasoningTokens')
         end
 
+        def cache_write_by_ttl(usage)
+          details = usage['cacheDetails']
+          return unless details.is_a?(Array)
+
+          details.each_with_object(Hash.new(0)) do |detail, counts|
+            counts[detail['ttl']] += detail['inputTokens'].to_i if detail['ttl']
+          end
+        end
+
         def format_messages(messages, caching: nil, automatic_cache_target: nil, citations: false)
           rendered = []
           tool_result_blocks = []
@@ -190,7 +198,9 @@ module RubyLLM
               }
             end
           end
-          blocks << converse_cache_block_for(caching) if cache_boundary?(msg, automatic_cache_target, caching:)
+          if cache_boundary?(msg, automatic_cache_target, caching:)
+            blocks << converse_cache_block_for(caching, ttl: msg.cache_ttl)
+          end
 
           blocks
         end
@@ -205,9 +215,13 @@ module RubyLLM
           blocks
         end
 
+        # Reasoning rebuilt from thinking text goes back only to the provider
+        # that produced it: Claude refuses another provider's signature, and
+        # a block without one.
         def format_thinking_blocks(msg)
           blocks = msg.raw_reasoning['converse'] if msg.raw_reasoning.is_a?(Hash)
           return Support::Utils.deep_dup(blocks) if blocks
+          return [] unless msg.thinking && producer_slug(msg) == @provider.slug
 
           [format_thinking_block(msg.thinking)].compact
         end
@@ -257,7 +271,7 @@ module RubyLLM
           messages.flat_map do |msg|
             blocks = Media.format_content(msg.content, msg.attachments, used_document_names: @used_document_names)
             if cache_boundary?(msg, automatic_cache_target, caching:)
-              blocks + [converse_cache_block_for(caching)]
+              blocks + [converse_cache_block_for(caching, ttl: msg.cache_ttl)]
             else
               blocks
             end
@@ -278,10 +292,11 @@ module RubyLLM
           caching != false && (message.cache_until_here? || message.equal?(automatic_cache_target))
         end
 
-        def converse_cache_block_for(caching)
+        def converse_cache_block_for(caching, ttl: nil)
           options = prompt_cache_options(caching)
+          ttl ||= options[:ttl]
           point = { type: 'default' }
-          point[:ttl] = options[:ttl] if options[:ttl]
+          point[:ttl] = ttl if ttl
           { cachePoint: point }
         end
 
@@ -356,7 +371,7 @@ module RubyLLM
         def format_additional_model_request_fields(thinking, model, max_output_tokens = nil)
           fields = {}
 
-          reasoning_fields = format_reasoning_fields(thinking, model, max_output_tokens)
+          reasoning_fields = Reasoning.format_reasoning_fields(thinking, model, max_output_tokens)
           fields = RubyLLM::Support::Utils.deep_merge(fields, reasoning_fields) if reasoning_fields
 
           fields.empty? ? nil : fields
@@ -382,136 +397,12 @@ module RubyLLM
           }
         end
 
-        NOVA_DEFAULT_REASONING_EFFORT = 'low'
-
-        def format_reasoning_fields(thinking, model, max_output_tokens = nil)
-          return nil unless thinking&.enabled?
-          return format_nova_reasoning_fields(thinking, model) if nova_model?(model)
-          return { reasoning_config: { type: 'disabled' } } if thinking.enabled == false
-
-          effort = thinking.effort.to_s
-          budget = reasoning_budget(thinking, effort, model, max_output_tokens)
-          return { reasoning_config: { type: 'enabled', budget_tokens: budget } } if budget
-          return nil if effort.empty? || effort == 'none'
-
-          { reasoning_effort: effort }
-        end
-
-        def nova_model?(model)
-          foundation_model_id(model&.id).start_with?('amazon.nova')
-        end
-
-        # Nova 2 takes reasoningConfig with an effort level instead of a token budget,
-        # and rejects an enabled reasoningConfig that names no effort.
-        def format_nova_reasoning_fields(thinking, model)
-          if thinking.budget
-            raise ArgumentError,
-                  "#{model&.id} takes a reasoning effort, not a token budget of #{thinking.budget}. " \
-                  'Pass with_thinking(effort:) instead.'
-          end
-
-          return { reasoningConfig: { type: 'disabled' } } if thinking.enabled == false
-
-          effort = thinking.effort.to_s
-          return nil if effort == 'none'
-
-          effort = NOVA_DEFAULT_REASONING_EFFORT if effort.empty?
-          { reasoningConfig: { type: 'enabled', maxReasoningEffort: effort } }
-        end
-
-        def reasoning_budget(thinking, effort, model, max_output_tokens)
-          return thinking.budget if thinking.budget.is_a?(Integer)
-          return nil if effort.empty? || effort == 'none'
-
-          schema = reasoning_budget_schema(model)
-          schema && effort_budget_tokens(effort, schema, model, max_output_tokens)
-        end
-
-        # Bedrock only publishes Converse metadata for some regional entries, so use the
-        # schema from another entry for the same foundation model when needed.
-        def reasoning_budget_schema(model)
-          schema = budget_tokens_schema(model)
-          return schema if schema
-          return unless model
-
-          foundation_id = foundation_model_id(model.id)
-          RubyLLM.models.all.each do |candidate|
-            next unless candidate.provider == 'bedrock' && candidate.id != model.id
-            next unless foundation_model_id(candidate.id) == foundation_id
-
-            return schema if (schema = budget_tokens_schema(candidate))
-          end
-
-          nil
-        end
-
-        def budget_tokens_schema(model)
-          metadata = RubyLLM::Support::Utils.deep_symbolize_keys(model&.metadata || {})
-          raw_schema = metadata.dig(:converse, :additionalRequestFieldsSchema)
-          return unless raw_schema.is_a?(String)
-
-          schema = JSON.parse(raw_schema, symbolize_names: true)
-          budget = schema.is_a?(Hash) ? schema.dig(:reasoningConfig, :budgetTokens) : nil
-          budget if budget.is_a?(Hash)
-        rescue JSON::ParserError
-          nil
-        end
-
         # Inference profile and foundation model ARNs name the model in their last segment.
         def foundation_model_id(model_id)
           prefixes = Converse::REGION_PREFIXES.join('|')
           model_id.to_s.rpartition('/').last.sub(/\A(?:#{prefixes})\./, '')
         end
 
-        # Models that take a budget reject reasoning_effort, so effort has to become a budget.
-        # Bedrock names the levels of an enumerated budget after the efforts they stand for;
-        # otherwise the effort spans the range the schema allows.
-        def effort_budget_tokens(effort, schema, model, max_output_tokens)
-          budget = enumerated_budget(effort, schema) || ranged_budget(effort, schema)
-          return nil unless budget
-
-          minimum = schema[:minimum].is_a?(Integer) ? schema[:minimum] : MINIMUM_BUDGET_TOKENS
-          return [budget, minimum].max unless max_output_tokens
-
-          budget.clamp(minimum, budget_ceiling(model, minimum, max_output_tokens))
-        end
-
-        # Bedrock rejects a budget that leaves no room for the answer.
-        def budget_ceiling(model, minimum, max_output_tokens)
-          ceiling = max_output_tokens - 1
-          return ceiling if minimum <= ceiling
-
-          raise ArgumentError, "#{model&.id} reasons on a budget of at least #{minimum} tokens, and " \
-                               "max_output_tokens: #{max_output_tokens} leaves room for #{ceiling}. " \
-                               "Raise max_output_tokens above #{minimum} or turn thinking off."
-        end
-
-        def enumerated_budget(effort, schema)
-          levels = schema[:enum]
-          level = levels.is_a?(Hash) ? levels[effort.to_sym] : nil
-          level if level.is_a?(Integer)
-        end
-
-        def ranged_budget(effort, schema)
-          minimum = schema[:minimum]
-          maximum = schema[:maximum]
-          return nil unless minimum.is_a?(Integer) && maximum.is_a?(Integer)
-
-          case effort
-          when 'low' then minimum
-          when 'medium' then minimum + ((maximum - minimum) / 2)
-          when 'high' then maximum
-          else raise ArgumentError, unknown_effort_message(effort, schema)
-          end
-        end
-
-        def unknown_effort_message(effort, schema)
-          levels = schema[:enum].is_a?(Hash) ? schema[:enum].keys.map(&:to_s) : []
-          levels |= RANGED_EFFORTS
-          "Bedrock has no reasoning budget for effort #{effort.inspect}. " \
-            "Use #{levels.join(', ')}, or pass an explicit budget."
-        end
-
         def format_thinking_block(thinking)
           return nil unless thinking
 

data/lib/ruby_llm/protocols/converse/media.rb

@@ -7,6 +7,20 @@ module RubyLLM
       module Media
         module_function
 
+        def supported_attachment?(attachment)
+          return supported_document_format?(attachment) if attachment.provider_file?
+
+          case attachment.type
+          when :image, :text then true
+          when :pdf, :document then supported_document_format?(attachment)
+          when :audio
+            SUPPORTED_AUDIO_FORMATS.include?(AUDIO_FORMAT_ALIASES.fetch(attachment.format, attachment.format))
+          when :video
+            SUPPORTED_VIDEO_FORMATS.include?(VIDEO_FORMAT_ALIASES.fetch(attachment.format, attachment.format))
+          else false
+          end
+        end
+
         def format_content(content, attachments = [], used_document_names: nil, citations: false)
           used_document_names ||= {}
           blocks = []
@@ -18,6 +32,8 @@ module RubyLLM
         end
 
         def format_attachment(attachment, used_document_names:, citations: false)
+          raise UnsupportedAttachmentError, attachment.mime_type unless supported_attachment?(attachment)
+
           if attachment.provider_file?
             return format_provider_file_attachment(attachment, used_document_names:, citations:)
           end
@@ -37,8 +53,6 @@ module RubyLLM
             else
               format_text_attachment(attachment)
             end
-          else
-            raise UnsupportedAttachmentError, attachment.mime_type
           end
         end
 

data/lib/ruby_llm/protocols/converse/reasoning.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RubyLLM
+  module Protocols
+    class Converse
+      # Reasoning request fields for Bedrock Converse, whose shape depends on
+      # the model family.
+      module Reasoning
+        RANGED_EFFORTS = %w[low medium high].freeze
+        MINIMUM_BUDGET_TOKENS = 1
+        NOVA_DEFAULT_REASONING_EFFORT = 'low'
+
+        module_function
+
+        def format_reasoning_fields(thinking, model, max_output_tokens = nil)
+          return nil unless thinking&.enabled?
+          return format_nova_reasoning_fields(thinking, model) if nova_model?(model)
+          return disabled_reasoning_fields(model) if thinking.enabled == false
+          return format_adaptive_reasoning_fields(thinking) if adaptive_thinking?(thinking, model)
+
+          effort = thinking.effort.to_s
+          budget = reasoning_budget(thinking, effort, model, max_output_tokens)
+          return { reasoning_config: { type: 'enabled', budget_tokens: budget } } if budget
+
+          format_effort_fields(effort, model) unless effort.empty?
+        end
+
+        def disabled_reasoning_fields(model)
+          return { thinking: { type: 'between_tools' } } if between_tools_off?(model)
+
+          { reasoning_config: { type: 'disabled' } }
+        end
+
+        def between_tools_off?(model)
+          return false unless model.respond_to?(:provider_class)
+
+          provider = model.provider_class
+          provider.respond_to?(:between_tools_off?) && provider.between_tools_off?(model.id)
+        end
+
+        # Models that publish a reasoning_config enum, such as OpenAI's GPT
+        # models, take the effort as its value and reject reasoning_effort.
+        def format_effort_fields(effort, model)
+          return { reasoning_config: effort } if reasoning_config_schema(model)
+
+          { reasoning_effort: effort } unless effort == 'none'
+        end
+
+        # Claude generations that take an effort but no budget only think
+        # adaptively, and reject a reasoning_config that enables a budget.
+        def adaptive_thinking?(thinking, model)
+          return false unless thinking.budget.nil?
+          return false unless Chat.foundation_model_id(model&.id).start_with?('anthropic.claude')
+
+          registered = registered_model(model)
+          !registered.nil? && !registered.reasoning_option(:effort).nil? &&
+            registered.reasoning_option(:budget_tokens).nil?
+        end
+
+        def format_adaptive_reasoning_fields(thinking)
+          effort = thinking.effort.to_s
+          return nil if effort == 'none'
+          return { thinking: { type: 'adaptive' } } if effort.empty?
+
+          { thinking: { type: 'adaptive' }, output_config: { effort: effort } }
+        end
+
+        # Inference profile ARNs and unlisted regional ids carry no reasoning
+        # options of their own, so use another entry for the same model.
+        def registered_model(model)
+          return model if model.reasoning_options.any?
+
+          foundation_id = Chat.foundation_model_id(model.id)
+          RubyLLM.models.all.find do |candidate|
+            candidate.provider == 'bedrock' && candidate.reasoning_options.any? &&
+              Chat.foundation_model_id(candidate.id) == foundation_id
+          end
+        end
+
+        def nova_model?(model)
+          Chat.foundation_model_id(model&.id).start_with?('amazon.nova')
+        end
+
+        # Nova 2 takes reasoningConfig with an effort level instead of a token budget,
+        # and rejects an enabled reasoningConfig that names no effort.
+        def format_nova_reasoning_fields(thinking, model)
+          if thinking.budget
+            raise ArgumentError,
+                  "#{model&.id} takes a reasoning effort, not a token budget of #{thinking.budget}. " \
+                  'Pass with_thinking(effort:) instead.'
+          end
+
+          return { reasoningConfig: { type: 'disabled' } } if thinking.enabled == false
+
+          effort = thinking.effort.to_s
+          return nil if effort == 'none'
+
+          effort = NOVA_DEFAULT_REASONING_EFFORT if effort.empty?
+          { reasoningConfig: { type: 'enabled', maxReasoningEffort: effort } }
+        end
+
+        def reasoning_budget(thinking, effort, model, max_output_tokens)
+          return thinking.budget if thinking.budget.is_a?(Integer)
+          return nil if effort.empty? || effort == 'none'
+
+          schema = reasoning_budget_schema(model)
+          schema && effort_budget_tokens(effort, schema, max_output_tokens)
+        end
+
+        def reasoning_budget_schema(model)
+          request_fields_schema(model) { |schema| schema.dig(:reasoningConfig, :budgetTokens) }
+        end
+
+        def reasoning_config_schema(model)
+          request_fields_schema(model) do |schema|
+            config = schema[:reasoning_config]
+            config if config.is_a?(Hash) && config[:type] == 'enum'
+          end
+        end
+
+        # Bedrock only publishes Converse metadata for some regional entries, so use the
+        # schema from another entry for the same foundation model when needed.
+        def request_fields_schema(model, &)
+          schema = published_schema(model, &)
+          return schema if schema
+          return unless model
+
+          foundation_id = Chat.foundation_model_id(model.id)
+          RubyLLM.models.all.each do |candidate|
+            next unless candidate.provider == 'bedrock' && candidate.id != model.id
+            next unless Chat.foundation_model_id(candidate.id) == foundation_id
+
+            return schema if (schema = published_schema(candidate, &))
+          end
+
+          nil
+        end
+
+        def published_schema(model)
+          metadata = RubyLLM::Support::Utils.deep_symbolize_keys(model&.metadata || {})
+          raw_schema = metadata.dig(:converse, :additionalRequestFieldsSchema)
+          return unless raw_schema.is_a?(String)
+
+          schema = JSON.parse(raw_schema, symbolize_names: true)
+          found = schema.is_a?(Hash) ? yield(schema) : nil
+          found if found.is_a?(Hash)
+        rescue JSON::ParserError
+          nil
+        end
+
+        # Models that take a budget reject reasoning_effort, so effort has to become a budget.
+        # Bedrock names the levels of an enumerated budget after the efforts they stand for;
+        # otherwise the effort spans the range the schema allows.
+        def effort_budget_tokens(effort, schema, max_output_tokens)
+          budget = enumerated_budget(effort, schema) || ranged_budget(effort, schema)
+          return nil unless budget
+
+          minimum = schema[:minimum].is_a?(Integer) ? schema[:minimum] : MINIMUM_BUDGET_TOKENS
+          return [budget, minimum].max unless max_output_tokens
+
+          budget.clamp(minimum, [max_output_tokens - 1, minimum].max)
+        end
+
+        def enumerated_budget(effort, schema)
+          levels = schema[:enum]
+          level = levels.is_a?(Hash) ? levels[effort.to_sym] : nil
+          level if level.is_a?(Integer)
+        end
+
+        def ranged_budget(effort, schema)
+          minimum = schema[:minimum]
+          maximum = schema[:maximum]
+          return nil unless minimum.is_a?(Integer) && maximum.is_a?(Integer)
+
+          case effort
+          when 'low' then minimum
+          when 'medium' then minimum + ((maximum - minimum) / 2)
+          when 'high' then maximum
+          else raise ArgumentError, unknown_effort_message(effort, schema)
+          end
+        end
+
+        def unknown_effort_message(effort, schema)
+          levels = schema[:enum].is_a?(Hash) ? schema[:enum].keys.map(&:to_s) : []
+          levels |= RANGED_EFFORTS
+          "Bedrock has no reasoning budget for effort #{effort.inspect}. " \
+            "Use #{levels.join(', ')}, or pass an explicit budget."
+        end
+      end
+    end
+  end
+end