dify_llm 1.9.2 → 1.14.1

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'openssl'
+
+module RubyLLM
+  module Providers
+    class Bedrock
+      # SigV4 authentication helpers for Bedrock.
+      module Auth
+        private
+
+        def signed_post(connection, url, payload, additional_headers = {})
+          request_payload = api_payload(payload)
+          body = JSON.generate(request_payload)
+          signed_headers = sign_headers('POST', url, body)
+
+          response = connection.post(url, request_payload) do |req|
+            req.headers.merge!(signed_headers)
+            req.headers.merge!(additional_headers) unless additional_headers.empty?
+            yield req if block_given?
+          end
+
+          parse_completion_response(response)
+        end
+
+        def signed_get(base_url, url)
+          conn = Connection.basic do |f|
+            f.request :json
+            f.response :json
+            f.adapter :net_http
+            f.use :llm_errors, provider: self
+          end
+
+          conn.url_prefix = base_url
+
+          conn.get(url) do |req|
+            req.headers.merge!(sign_headers('GET', url, '', base_url: base_url))
+          end
+        end
+
+        def sign_headers(method, path, body, base_url: api_base)
+          now = Time.now.utc
+          amz_date = now.strftime('%Y%m%dT%H%M%SZ')
+          date_stamp = now.strftime('%Y%m%d')
+
+          uri = URI.parse(path)
+          canonical_uri = canonical_uri(uri.path)
+          canonical_query = canonical_query_string(uri.query)
+          payload_hash = Digest::SHA256.hexdigest(body)
+
+          headers = {
+            'host' => URI.parse(base_url).host,
+            'x-amz-content-sha256' => payload_hash,
+            'x-amz-date' => amz_date
+          }
+          headers['x-amz-security-token'] = @config.bedrock_session_token if @config.bedrock_session_token
+
+          signed_headers = headers.keys.sort.join(';')
+          canonical_headers = headers.keys.sort.map { |key| "#{key}:#{headers[key].to_s.strip}\n" }.join
+
+          canonical_request = [
+            method,
+            canonical_uri,
+            canonical_query,
+            canonical_headers,
+            signed_headers,
+            payload_hash
+          ].join("\n")
+
+          credential_scope = "#{date_stamp}/#{bedrock_region}/bedrock/aws4_request"
+          string_to_sign = [
+            'AWS4-HMAC-SHA256',
+            amz_date,
+            credential_scope,
+            Digest::SHA256.hexdigest(canonical_request)
+          ].join("\n")
+
+          signing_key = signing_key(date_stamp)
+          signature = OpenSSL::HMAC.hexdigest('sha256', signing_key, string_to_sign)
+
+          {
+            'X-Amz-Date' => amz_date,
+            'X-Amz-Content-Sha256' => payload_hash,
+            'X-Amz-Security-Token' => @config.bedrock_session_token,
+            'Authorization' => "AWS4-HMAC-SHA256 Credential=#{@config.bedrock_api_key}/#{credential_scope}, " \
+                               "SignedHeaders=#{signed_headers}, Signature=#{signature}",
+            'Content-Type' => 'application/json'
+          }.compact
+        end
+
+        def canonical_query_string(raw_query)
+          return '' if raw_query.nil? || raw_query.empty?
+
+          URI.decode_www_form(raw_query)
+             .sort_by(&:first)
+             .map { |k, v| "#{uri_encode(k)}=#{uri_encode(v)}" }
+             .join('&')
+        end
+
+        def canonical_uri(path)
+          return '/' if path.nil? || path.empty?
+
+          segments = path.split('/', -1).map { |segment| uri_encode(segment) }
+          canonical = segments.join('/')
+          canonical.start_with?('/') ? canonical : "/#{canonical}"
+        end
+
+        def uri_encode(text)
+          URI.encode_www_form_component(text.to_s).gsub('+', '%20').gsub('%7E', '~')
+        end
+
+        def signing_key(date_stamp)
+          k_date = OpenSSL::HMAC.digest('sha256', "AWS4#{@config.bedrock_secret_key}", date_stamp)
+          k_region = OpenSSL::HMAC.digest('sha256', k_date, bedrock_region)
+          k_service = OpenSSL::HMAC.digest('sha256', k_region, 'bedrock')
+          OpenSSL::HMAC.digest('sha256', k_service, 'aws4_request')
+        end
+      end
+    end
+  end
+end

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

@@ -3,58 +3,387 @@
 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?
+        def completion_url
+          "/model/#{@model.id}/converse"
+        end
+
+        # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
+        def render_payload(messages, tools:, temperature:, model:, stream: false,
+                           schema: nil, thinking: nil, tool_prefs: nil)
+          tool_prefs ||= {}
+          @model = model
+          @used_document_names = {}
+          system_messages, chat_messages = messages.partition { |msg| msg.role == :system }
+          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, tool_prefs)
+          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
+
+          output_config = build_output_config(schema)
+          payload[:outputConfig] = output_config if output_config
+
+          payload
+        end
+        # rubocop:enable Metrics/ParameterLists,Lint/UnusedMethodArgument
+
+        def parse_completion_response(response)
+          data = response.body
+          return if data.nil? || data.empty?
+
+          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_messages(messages)
+          rendered = []
+          tool_result_blocks = []
+
+          messages.each do |msg|
+            if msg.tool_result?
+              tool_result_blocks << render_tool_result_block(msg)
+              next
+            end
+
+            unless tool_result_blocks.empty?
+              rendered << { role: 'user', content: tool_result_blocks }
+              tool_result_blocks = []
+            end
+
+            message = render_non_tool_message(msg)
+            rendered << message if message
           end
-          Anthropic::Chat.parse_completion_response response
+
+          rendered << { role: 'user', content: tool_result_blocks } unless tool_result_blocks.empty?
+          rendered
         end
 
-        def format_message(msg)
+        def render_non_tool_message(msg)
+          content = render_message_content(msg)
+          return nil if content.empty?
+
+          {
+            role: render_role(msg.role),
+            content: content
+          }
+        end
+
+        def render_message_content(msg)
+          if msg.content.is_a?(RubyLLM::Content::Raw)
+            return render_raw_content(msg.content) if msg.role == :assistant
+
+            return sanitize_non_assistant_raw_blocks(render_raw_content(msg.content))
+          end
+
+          blocks = []
+
+          thinking_block = render_thinking_block(msg.thinking)
+          blocks << thinking_block if msg.role == :assistant && 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?
-            Anthropic::Tools.format_tool_call(msg)
-          elsif msg.tool_result?
-            Anthropic::Tools.format_tool_result(msg)
+            msg.tool_calls.each_value do |tool_call|
+              blocks << {
+                toolUse: {
+                  toolUseId: tool_call.id,
+                  name: tool_call.name,
+                  input: tool_call.arguments
+                }
+              }
+            end
+          end
+
+          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)
+          {
+            toolResult: {
+              toolUseId: msg.tool_call_id,
+              content: render_tool_result_content(msg.content)
+            }
+          }
+        end
+
+        def render_tool_result_content(content)
+          return render_raw_tool_result_content(content.value) if content.is_a?(RubyLLM::Content::Raw)
+
+          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
+
+        def render_raw_tool_result_content(raw_value)
+          blocks = raw_value.is_a?(Array) ? raw_value : [raw_value]
+
+          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, tool_prefs)
+          return nil if tools.empty?
+
+          config = {
+            tools: tools.values.map { |tool| render_tool(tool) }
+          }
+
+          return config if tool_prefs.nil? || tool_prefs[:choice].nil?
+
+          tool_choice = render_tool_choice(tool_prefs[:choice])
+          config[:toolChoice] = tool_choice if tool_choice
+          config
+        end
+
+        def render_tool_choice(choice)
+          case choice
+          when :auto
+            { auto: {} }
+          when :none
+            nil
+          when :required
+            { any: {} }
           else
-            format_basic_message(msg)
+            { tool: { name: choice.to_s } }
           end
         end
 
-        def format_basic_message(msg)
+        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 build_output_config(schema)
+          return nil unless schema
+
+          cleaned = RubyLLM::Utils.deep_dup(schema[:schema])
+          cleaned.delete(:strict)
+          cleaned.delete('strict')
+
           {
-            role: Anthropic::Chat.convert_role(msg.role),
-            content: Media.format_content(msg.content)
+            textFormat: {
+              type: 'json_schema',
+              structure: {
+                jsonSchema: {
+                  schema: JSON.generate(cleaned),
+                  name: schema[:name]
+                }
+              }
+            }
           }
         end
 
-        private
+        def render_reasoning_fields(thinking)
+          return nil unless thinking&.enabled?
 
-        def completion_url
-          "model/#{@model_id}/invoke"
+          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
+            { 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 render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil) # rubocop:disable Lint/UnusedMethodArgument,Metrics/ParameterLists
-          @model_id = model.id
+        def parse_reasoning_content_block(block)
+          reasoning_content = block['reasoningContent']
+          return [nil, nil] unless reasoning_content.is_a?(Hash)
 
-          system_messages, chat_messages = Anthropic::Chat.separate_messages(messages)
-          system_content = Anthropic::Chat.build_system_content(system_messages)
+          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
 
-          build_base_payload(chat_messages, model).tap do |payload|
-            Anthropic::Chat.add_optional_fields(payload, system_content:, tools:, temperature:)
+        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 build_base_payload(chat_messages, model)
+        def default_input_schema
           {
-            anthropic_version: 'bedrock-2023-05-31',
-            messages: chat_messages.map { |msg| format_message(msg) },
-            max_tokens: model.max_tokens || 4096
+            'type' => 'object',
+            'properties' => {},
+            'required' => []
           }
         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