ruby_llm 1.11.0 → 1.12.1

data/lib/ruby_llm/providers/bedrock/chat.rb

@@ -3,112 +3,344 @@
 module RubyLLM
   module Providers
     class Bedrock
-      # Chat methods for the AWS Bedrock API implementation
+      # Chat methods for Bedrock Converse API.
       module Chat
         module_function
 
-        def sync_response(connection, payload, additional_headers = {})
-          signature = sign_request("#{connection.connection.url_prefix}#{completion_url}", payload:)
-          response = connection.post completion_url, payload do |req|
-            req.headers.merge! build_headers(signature.headers, streaming: block_given?)
-            req.headers = additional_headers.merge(req.headers) unless additional_headers.empty?
-          end
-          Anthropic::Chat.parse_completion_response response
+        def completion_url
+          "/model/#{@model.id}/converse"
         end
 
-        def format_message(msg, thinking: nil)
-          thinking_enabled = thinking&.enabled?
+        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil, thinking: nil) # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
+          @model = model
+          @used_document_names = {}
+          system_messages, chat_messages = messages.partition { |msg| msg.role == :system }
 
-          if msg.tool_call?
-            format_tool_call_with_thinking(msg, thinking_enabled)
-          elsif msg.tool_result?
-            Anthropic::Tools.format_tool_result(msg)
-          else
-            format_basic_message_with_thinking(msg, thinking_enabled)
+          payload = {
+            messages: render_messages(chat_messages)
+          }
+
+          system_blocks = render_system(system_messages)
+          payload[:system] = system_blocks unless system_blocks.empty?
+
+          payload[:inferenceConfig] = render_inference_config(model, temperature)
+
+          tool_config = render_tool_config(tools)
+          if tool_config
+            payload[:toolConfig] = tool_config
+            payload[:tools] = tool_config[:tools] # Internal mirror for shared payload inspections in specs.
           end
+
+          additional_fields = render_additional_model_request_fields(thinking)
+          payload[:additionalModelRequestFields] = additional_fields if additional_fields
+
+          payload
         end
 
-        private
+        def parse_completion_response(response)
+          data = response.body
+          return if data.nil? || data.empty?
 
-        def completion_url
-          "model/#{@model_id}/invoke"
+          content_blocks = data.dig('output', 'message', 'content') || []
+          usage = data['usage'] || {}
+          thinking_text, thinking_signature = parse_thinking(content_blocks)
+
+          Message.new(
+            role: :assistant,
+            content: parse_text_content(content_blocks),
+            thinking: Thinking.build(text: thinking_text, signature: thinking_signature),
+            tool_calls: parse_tool_calls(content_blocks),
+            input_tokens: usage['inputTokens'],
+            output_tokens: usage['outputTokens'],
+            cached_tokens: usage['cacheReadInputTokens'],
+            cache_creation_tokens: usage['cacheWriteInputTokens'],
+            thinking_tokens: usage['reasoningTokens'],
+            model_id: data['modelId'],
+            raw: response
+          )
         end
 
-        def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil, thinking: nil) # rubocop:disable Lint/UnusedMethodArgument,Metrics/ParameterLists
-          @model_id = model.id
+        def render_messages(messages)
+          rendered = []
+          tool_result_blocks = []
+
+          messages.each do |msg|
+            if msg.tool_result?
+              tool_result_blocks << render_tool_result_block(msg)
+              next
+            end
 
-          system_messages, chat_messages = Anthropic::Chat.separate_messages(messages)
-          system_content = Anthropic::Chat.build_system_content(system_messages)
+            unless tool_result_blocks.empty?
+              rendered << { role: 'user', content: tool_result_blocks }
+              tool_result_blocks = []
+            end
 
-          build_base_payload(chat_messages, model, thinking).tap do |payload|
-            Anthropic::Chat.add_optional_fields(payload, system_content:, tools:, temperature:)
+            message = render_non_tool_message(msg)
+            rendered << message if message
           end
+
+          rendered << { role: 'user', content: tool_result_blocks } unless tool_result_blocks.empty?
+          rendered
         end
 
-        def build_base_payload(chat_messages, model, thinking)
-          payload = {
-            anthropic_version: 'bedrock-2023-05-31',
-            messages: chat_messages.map { |msg| format_message(msg, thinking: thinking) },
-            max_tokens: model.max_tokens || 4096
+        def render_non_tool_message(msg)
+          content = render_message_content(msg)
+          return nil if content.empty?
+
+          {
+            role: render_role(msg.role),
+            content: content
           }
+        end
 
-          thinking_payload = Anthropic::Chat.build_thinking_payload(thinking)
-          payload[:thinking] = thinking_payload if thinking_payload
+        def render_message_content(msg)
+          if msg.content.is_a?(RubyLLM::Content::Raw)
+            return render_raw_content(msg.content) if msg.role == :assistant
 
-          payload
-        end
+            return sanitize_non_assistant_raw_blocks(render_raw_content(msg.content))
+          end
+
+          blocks = []
 
-        def format_basic_message_with_thinking(msg, thinking_enabled)
-          content_blocks = []
+          thinking_block = render_thinking_block(msg.thinking)
+          blocks << thinking_block if msg.role == :assistant && thinking_block
 
-          if msg.role == :assistant && thinking_enabled
-            thinking_block = Anthropic::Chat.build_thinking_block(msg.thinking)
-            content_blocks << thinking_block if thinking_block
+          text_and_media_blocks = Media.render_content(msg.content, used_document_names: @used_document_names)
+          blocks.concat(text_and_media_blocks) if text_and_media_blocks
+
+          if msg.tool_call?
+            msg.tool_calls.each_value do |tool_call|
+              blocks << {
+                toolUse: {
+                  toolUseId: tool_call.id,
+                  name: tool_call.name,
+                  input: tool_call.arguments
+                }
+              }
+            end
           end
 
-          append_formatted_content(content_blocks, msg.content)
+          blocks
+        end
 
+        def render_raw_content(content)
+          value = content.value
+          value.is_a?(Array) ? value : [value]
+        end
+
+        def sanitize_non_assistant_raw_blocks(blocks)
+          blocks.filter_map do |block|
+            next unless block.is_a?(Hash)
+            next if block.key?(:reasoningContent) || block.key?('reasoningContent')
+
+            block
+          end
+        end
+
+        def render_tool_result_block(msg)
           {
-            role: Anthropic::Chat.convert_role(msg.role),
-            content: content_blocks
+            toolResult: {
+              toolUseId: msg.tool_call_id,
+              content: render_tool_result_content(msg.content)
+            }
           }
         end
 
-        def format_tool_call_with_thinking(msg, thinking_enabled)
-          if msg.content.is_a?(RubyLLM::Content::Raw)
-            content_blocks = msg.content.value
-            content_blocks = [content_blocks] unless content_blocks.is_a?(Array)
-            content_blocks = Anthropic::Chat.prepend_thinking_block(content_blocks, msg, thinking_enabled)
+        def render_tool_result_content(content)
+          return render_raw_tool_result_content(content.value) if content.is_a?(RubyLLM::Content::Raw)
 
-            return { role: 'assistant', content: content_blocks }
+          if content.is_a?(Hash) || content.is_a?(Array)
+            [{ json: content }]
+          elsif content.is_a?(RubyLLM::Content)
+            blocks = []
+            blocks << { text: content.text } if content.text
+            content.attachments.each do |attachment|
+              blocks << { text: attachment.for_llm }
+            end
+            blocks
+          else
+            [{ text: content.to_s }]
           end
+        end
 
-          content_blocks = Anthropic::Chat.prepend_thinking_block([], msg, thinking_enabled)
-          content_blocks << Anthropic::Media.format_text(msg.content) unless msg.content.nil? || msg.content.empty?
+        def render_raw_tool_result_content(raw_value)
+          blocks = raw_value.is_a?(Array) ? raw_value : [raw_value]
 
-          msg.tool_calls.each_value do |tool_call|
-            content_blocks << {
-              type: 'tool_use',
-              id: tool_call.id,
-              name: tool_call.name,
-              input: tool_call.arguments
-            }
+          normalized = blocks.filter_map do |block|
+            normalize_tool_result_block(block)
+          end
+
+          normalized.empty? ? [{ text: raw_value.to_s }] : normalized
+        end
+
+        def normalize_tool_result_block(block)
+          return nil unless block.is_a?(Hash)
+          return block if tool_result_content_block?(block)
+
+          nil
+        end
+
+        def tool_result_content_block?(block)
+          %w[text json document image].any? do |key|
+            block.key?(key) || block.key?(key.to_sym)
+          end
+        end
+
+        def render_role(role)
+          case role
+          when :assistant then 'assistant'
+          else 'user'
           end
+        end
+
+        def render_system(messages)
+          messages.flat_map { |msg| Media.render_content(msg.content, used_document_names: @used_document_names) }
+        end
+
+        def render_inference_config(_model, temperature)
+          config = {}
+          config[:temperature] = temperature unless temperature.nil?
+          config
+        end
+
+        def render_tool_config(tools)
+          return nil if tools.empty?
 
           {
-            role: 'assistant',
-            content: content_blocks
+            tools: tools.values.map { |tool| render_tool(tool) }
           }
         end
 
-        def append_formatted_content(content_blocks, content)
-          formatted_content = Media.format_content(content)
-          if formatted_content.is_a?(Array)
-            content_blocks.concat(formatted_content)
+        def render_tool(tool)
+          input_schema = tool.params_schema || RubyLLM::Tool::SchemaDefinition.from_parameters(tool.parameters)&.json_schema
+
+          tool_spec = {
+            toolSpec: {
+              name: tool.name,
+              description: tool.description,
+              inputSchema: {
+                json: input_schema || default_input_schema
+              }
+            }
+          }
+
+          return tool_spec if tool.provider_params.empty?
+
+          RubyLLM::Utils.deep_merge(tool_spec, tool.provider_params)
+        end
+
+        def render_additional_model_request_fields(thinking)
+          fields = {}
+
+          reasoning_fields = render_reasoning_fields(thinking)
+          fields = RubyLLM::Utils.deep_merge(fields, reasoning_fields) if reasoning_fields
+
+          fields.empty? ? nil : fields
+        end
+
+        def render_reasoning_fields(thinking)
+          return nil unless thinking&.enabled?
+
+          effort_config = effort_reasoning_config(thinking)
+          return effort_config if effort_config
+
+          budget_reasoning_config(thinking)
+        end
+
+        def effort_reasoning_config(thinking)
+          effort = thinking.respond_to?(:effort) ? thinking.effort : nil
+          effort = effort.to_s if effort
+          return nil if effort.nil? || effort.empty? || effort == 'none'
+
+          if reasoning_embedded?(@model)
+            { reasoning_config: { type: 'enabled', reasoning_effort: effort } }
           else
-            content_blocks << formatted_content
+            { reasoning_effort: effort }
+          end
+        end
+
+        def budget_reasoning_config(thinking)
+          budget = thinking.respond_to?(:budget) ? thinking.budget : thinking
+          return nil unless budget.is_a?(Integer)
+
+          { reasoning_config: { type: 'enabled', budget_tokens: budget } }
+        end
+
+        def render_thinking_block(thinking)
+          return nil unless thinking
+
+          if thinking.text
+            {
+              reasoningContent: {
+                reasoningText: {
+                  text: thinking.text,
+                  signature: thinking.signature
+                }.compact
+              }
+            }
+          elsif thinking.signature
+            {
+              reasoningContent: {
+                redactedContent: thinking.signature
+              }
+            }
           end
         end
+
+        def parse_text_content(content_blocks)
+          text = content_blocks.filter_map { |block| block['text'] if block['text'].is_a?(String) }.join
+          text.empty? ? nil : text
+        end
+
+        def parse_thinking(content_blocks)
+          text = +''
+          signature = nil
+
+          content_blocks.each do |block|
+            chunk_text, chunk_signature = parse_reasoning_content_block(block)
+            text << chunk_text if chunk_text
+            signature ||= chunk_signature
+          end
+
+          [text.empty? ? nil : text, signature]
+        end
+
+        def parse_reasoning_content_block(block)
+          reasoning_content = block['reasoningContent']
+          return [nil, nil] unless reasoning_content.is_a?(Hash)
+
+          reasoning_text = reasoning_content['reasoningText'] || {}
+          text = reasoning_text['text'].is_a?(String) ? reasoning_text['text'] : nil
+          signature = reasoning_text['signature'] if reasoning_text['signature'].is_a?(String)
+          signature ||= reasoning_content['redactedContent'] if reasoning_content['redactedContent'].is_a?(String)
+          [text, signature]
+        end
+
+        def parse_tool_calls(content_blocks)
+          tool_calls = {}
+
+          content_blocks.each do |block|
+            tool_use = block['toolUse']
+            next unless tool_use
+
+            tool_call_id = tool_use['toolUseId']
+            tool_calls[tool_call_id] = ToolCall.new(
+              id: tool_call_id,
+              name: tool_use['name'],
+              arguments: tool_use['input'] || {}
+            )
+          end
+
+          tool_calls.empty? ? nil : tool_calls
+        end
+
+        def default_input_schema
+          {
+            'type' => 'object',
+            'properties' => {},
+            'required' => []
+          }
+        end
       end
     end
   end

data/lib/ruby_llm/providers/bedrock/media.rb

@@ -3,58 +3,87 @@
 module RubyLLM
   module Providers
     class Bedrock
-      # Media handling methods for the Bedrock API integration
-      # NOTE: Bedrock does not support url attachments
+      # Media formatting for Bedrock Converse content blocks.
       module Media
-        extend Anthropic::Media
-
         module_function
 
-        def format_content(content) # rubocop:disable Metrics/PerceivedComplexity
-          return content.value if content.is_a?(RubyLLM::Content::Raw)
-          return [Anthropic::Media.format_text(content.to_json)] if content.is_a?(Hash) || content.is_a?(Array)
-          return [Anthropic::Media.format_text(content)] unless content.is_a?(Content)
+        def render_content(content, used_document_names: nil)
+          return [] if empty_content?(content)
+          return render_raw_content(content) if content.is_a?(RubyLLM::Content::Raw)
+          return [{ text: content.to_json }] if content.is_a?(Hash) || content.is_a?(Array)
+          return [{ text: content }] unless content.is_a?(RubyLLM::Content)
+
+          render_content_object(content, used_document_names || {})
+        end
 
-          parts = []
-          parts << Anthropic::Media.format_text(content.text) if content.text
+        def empty_content?(content)
+          content.nil? || (content.respond_to?(:empty?) && content.empty?)
+        end
 
+        def render_content_object(content, used_document_names)
+          blocks = []
+          blocks << { text: content.text } if content.text
           content.attachments.each do |attachment|
-            case attachment.type
-            when :image
-              parts << format_image(attachment)
-            when :pdf
-              parts << format_pdf(attachment)
-            when :text
-              parts << Anthropic::Media.format_text_file(attachment)
-            else
-              raise UnsupportedAttachmentError, attachment.type
-            end
+            blocks << render_attachment(attachment, used_document_names:)
           end
+          blocks
+        end
 
-          parts
+        def render_raw_content(content)
+          value = content.value
+          value.is_a?(Array) ? value : [value]
         end
 
-        def format_image(image)
+        def render_attachment(attachment, used_document_names:)
+          case attachment.type
+          when :image
+            render_image_attachment(attachment)
+          when :pdf
+            render_document_attachment(attachment, used_document_names:)
+          when :text
+            { text: attachment.for_llm }
+          else
+            raise UnsupportedAttachmentError, attachment.mime_type
+          end
+        end
+
+        def render_image_attachment(attachment)
           {
-            type: 'image',
-            source: {
-              type: 'base64',
-              media_type: image.mime_type,
-              data: image.encoded
+            image: {
+              format: attachment.format,
+              source: {
+                bytes: attachment.encoded
+              }
             }
           }
         end
 
-        def format_pdf(pdf)
+        def render_document_attachment(attachment, used_document_names:)
+          document_name = unique_document_name(sanitize_document_name(attachment.filename), used_document_names)
           {
-            type: 'document',
-            source: {
-              type: 'base64',
-              media_type: pdf.mime_type,
-              data: pdf.encoded
+            document: {
+              format: attachment.format,
+              name: document_name,
+              source: {
+                bytes: attachment.encoded
+              }
             }
           }
         end
+
+        def sanitize_document_name(filename)
+          base = File.basename(filename.to_s, '.*')
+          safe = base.gsub(/[^a-zA-Z0-9_-]/, '_')
+          safe.empty? ? 'document' : safe
+        end
+
+        def unique_document_name(base_name, used_names)
+          count = used_names[base_name].to_i
+          used_names[base_name] = count + 1
+          return base_name if count.zero?
+
+          "#{base_name}_#{count + 1}"
+        end
       end
     end
   end