ruby_llm 1.10.0 → 1.12.0

data/lib/ruby_llm/providers/bedrock/streaming/base.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class Bedrock
-      module Streaming
-        # Base module for AWS Bedrock streaming functionality.
-        module Base
-          def self.included(base)
-            base.include ContentExtraction
-            base.include MessageProcessing
-            base.include PayloadProcessing
-            base.include PreludeHandling
-          end
-
-          def stream_url
-            "model/#{@model_id}/invoke-with-response-stream"
-          end
-
-          def stream_response(connection, payload, additional_headers = {}, &block)
-            signature = sign_request("#{connection.connection.url_prefix}#{stream_url}", payload:)
-            accumulator = StreamAccumulator.new
-
-            response = connection.post stream_url, payload do |req|
-              req.headers.merge! build_headers(signature.headers, streaming: block_given?)
-              # Merge additional headers, with existing headers taking precedence
-              req.headers = additional_headers.merge(req.headers) unless additional_headers.empty?
-              req.options.on_data = handle_stream do |chunk|
-                accumulator.add chunk
-                block.call chunk
-              end
-            end
-
-            accumulator.to_message(response)
-          end
-
-          def handle_stream(&block)
-            buffer = +''
-            proc do |chunk, _bytes, env|
-              if env && env.status != 200
-                handle_failed_response(chunk, buffer, env)
-              else
-                process_chunk(chunk, &block)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/providers/bedrock/streaming/content_extraction.rb

@@ -1,128 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class Bedrock
-      module Streaming
-        # Module for handling content extraction from AWS Bedrock streaming responses.
-        module ContentExtraction
-          def json_delta?(data)
-            data['type'] == 'content_block_delta' && data.dig('delta', 'type') == 'input_json_delta'
-          end
-
-          def extract_streaming_content(data)
-            return '' unless data.is_a?(Hash)
-
-            extract_content_by_type(data)
-          end
-
-          def extract_thinking_delta(data)
-            return nil unless data.is_a?(Hash)
-
-            if data['type'] == 'content_block_delta' && data.dig('delta', 'type') == 'thinking_delta'
-              return data.dig('delta', 'thinking')
-            end
-
-            if data['type'] == 'content_block_start' && data.dig('content_block', 'type') == 'thinking'
-              return data.dig('content_block', 'thinking') || data.dig('content_block', 'text')
-            end
-
-            nil
-          end
-
-          def extract_signature_delta(data)
-            return nil unless data.is_a?(Hash)
-
-            signature = extract_signature_from_delta(data)
-            return signature if signature
-
-            return nil unless data['type'] == 'content_block_start'
-
-            extract_signature_from_block(data['content_block'])
-          end
-
-          def extract_tool_calls(data)
-            data.dig('message', 'tool_calls') || data['tool_calls']
-          end
-
-          def extract_model_id(data)
-            data.dig('message', 'model') || @model_id
-          end
-
-          def extract_input_tokens(data)
-            data.dig('message', 'usage', 'input_tokens')
-          end
-
-          def extract_output_tokens(data)
-            data.dig('message', 'usage', 'output_tokens') || data.dig('usage', 'output_tokens')
-          end
-
-          def extract_cached_tokens(data)
-            data.dig('message', 'usage', 'cache_read_input_tokens') || data.dig('usage', 'cache_read_input_tokens')
-          end
-
-          def extract_cache_creation_tokens(data)
-            direct = data.dig('message', 'usage',
-                              'cache_creation_input_tokens') || data.dig('usage', 'cache_creation_input_tokens')
-            return direct if direct
-
-            breakdown = data.dig('message', 'usage', 'cache_creation') || data.dig('usage', 'cache_creation')
-            return unless breakdown.is_a?(Hash)
-
-            breakdown.values.compact.sum
-          end
-
-          def extract_thinking_tokens(data)
-            data.dig('message', 'usage', 'thinking_tokens') ||
-              data.dig('message', 'usage', 'output_tokens_details', 'thinking_tokens') ||
-              data.dig('usage', 'thinking_tokens') ||
-              data.dig('usage', 'output_tokens_details', 'thinking_tokens') ||
-              data.dig('message', 'usage', 'reasoning_tokens') ||
-              data.dig('message', 'usage', 'output_tokens_details', 'reasoning_tokens') ||
-              data.dig('usage', 'reasoning_tokens') ||
-              data.dig('usage', 'output_tokens_details', 'reasoning_tokens')
-          end
-
-          private
-
-          def extract_content_by_type(data)
-            case data['type']
-            when 'content_block_start' then extract_block_start_content(data)
-            when 'content_block_delta' then extract_delta_content(data)
-            else ''
-            end
-          end
-
-          def extract_block_start_content(data)
-            content_block = data['content_block'] || {}
-            return '' if %w[thinking redacted_thinking].include?(content_block['type'])
-
-            content_block['text'].to_s
-          end
-
-          def extract_delta_content(data)
-            delta = data['delta'] || {}
-            return '' if %w[thinking_delta signature_delta].include?(delta['type'])
-
-            delta['text'].to_s
-          end
-
-          def extract_signature_from_delta(data)
-            return unless data['type'] == 'content_block_delta'
-            return unless data.dig('delta', 'type') == 'signature_delta'
-
-            data.dig('delta', 'signature')
-          end
-
-          def extract_signature_from_block(content_block)
-            block = content_block || {}
-            return block['signature'] if block['type'] == 'thinking' && block['signature']
-            return block['data'] if block['type'] == 'redacted_thinking'
-
-            nil
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/providers/bedrock/streaming/message_processing.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class Bedrock
-      module Streaming
-        # Module for processing streaming messages from AWS Bedrock.
-        module MessageProcessing
-          def process_chunk(chunk, &)
-            offset = 0
-            offset = process_message(chunk, offset, &) while offset < chunk.bytesize
-          rescue StandardError => e
-            RubyLLM.logger.debug "Error processing chunk: #{e.message}"
-            RubyLLM.logger.debug "Chunk size: #{chunk.bytesize}"
-          end
-
-          def process_message(chunk, offset, &)
-            return chunk.bytesize unless can_read_prelude?(chunk, offset)
-
-            message_info = extract_message_info(chunk, offset)
-            return find_next_message(chunk, offset) unless message_info
-
-            process_valid_message(chunk, offset, message_info, &)
-          end
-
-          def process_valid_message(chunk, offset, message_info, &)
-            payload = extract_payload(chunk, message_info[:headers_end], message_info[:payload_end])
-            return find_next_message(chunk, offset) unless valid_payload?(payload)
-
-            process_payload(payload, &)
-            offset + message_info[:total_length]
-          end
-
-          private
-
-          def extract_message_info(chunk, offset)
-            total_length, headers_length = read_prelude(chunk, offset)
-            return unless valid_lengths?(total_length, headers_length)
-
-            message_end = offset + total_length
-            return unless chunk.bytesize >= message_end
-
-            headers_end, payload_end = calculate_positions(offset, total_length, headers_length)
-            return unless valid_positions?(headers_end, payload_end, chunk.bytesize)
-
-            { total_length:, headers_length:, headers_end:, payload_end: }
-          end
-
-          def extract_payload(chunk, headers_end, payload_end)
-            chunk[headers_end...payload_end]
-          end
-
-          def valid_payload?(payload)
-            return false if payload.nil? || payload.empty?
-
-            json_start = payload.index('{')
-            json_end = payload.rindex('}')
-
-            return false if json_start.nil? || json_end.nil? || json_start >= json_end
-
-            true
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/providers/bedrock/streaming/payload_processing.rb

@@ -1,85 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-
-module RubyLLM
-  module Providers
-    class Bedrock
-      module Streaming
-        # Module for processing payloads from AWS Bedrock streaming responses.
-        module PayloadProcessing
-          def process_payload(payload, &)
-            json_payload = extract_json_payload(payload)
-            parse_and_process_json(json_payload, &)
-          rescue JSON::ParserError => e
-            log_json_parse_error(e, json_payload)
-          rescue StandardError => e
-            log_general_error(e)
-          end
-
-          private
-
-          def extract_json_payload(payload)
-            json_start = payload.index('{')
-            json_end = payload.rindex('}')
-            payload[json_start..json_end]
-          end
-
-          def parse_and_process_json(json_payload, &)
-            json_data = JSON.parse(json_payload)
-            process_json_data(json_data, &)
-          end
-
-          def process_json_data(json_data, &)
-            return unless json_data['bytes']
-
-            data = decode_and_parse_data(json_data)
-            create_and_yield_chunk(data, &)
-          end
-
-          def decode_and_parse_data(json_data)
-            decoded_bytes = Base64.strict_decode64(json_data['bytes'])
-            JSON.parse(decoded_bytes)
-          end
-
-          def create_and_yield_chunk(data, &block)
-            block.call(build_chunk(data))
-          end
-
-          def build_chunk(data)
-            Chunk.new(
-              **extract_chunk_attributes(data)
-            )
-          end
-
-          def extract_chunk_attributes(data)
-            {
-              role: :assistant,
-              model_id: extract_model_id(data),
-              content: extract_streaming_content(data),
-              thinking: Thinking.build(
-                text: extract_thinking_delta(data),
-                signature: extract_signature_delta(data)
-              ),
-              input_tokens: extract_input_tokens(data),
-              output_tokens: extract_output_tokens(data),
-              cached_tokens: extract_cached_tokens(data),
-              cache_creation_tokens: extract_cache_creation_tokens(data),
-              thinking_tokens: extract_thinking_tokens(data),
-              tool_calls: extract_tool_calls(data)
-            }
-          end
-
-          def log_json_parse_error(error, json_payload)
-            RubyLLM.logger.debug "Failed to parse payload as JSON: #{error.message}"
-            RubyLLM.logger.debug "Attempted JSON payload: #{json_payload.inspect}"
-          end
-
-          def log_general_error(error)
-            RubyLLM.logger.debug "Error processing payload: #{error.message}"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/providers/bedrock/streaming/prelude_handling.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module Providers
-    class Bedrock
-      module Streaming
-        # Module for handling message preludes in AWS Bedrock streaming responses.
-        module PreludeHandling
-          def can_read_prelude?(chunk, offset)
-            chunk.bytesize - offset >= 12
-          end
-
-          def read_prelude(chunk, offset)
-            total_length = chunk[offset...(offset + 4)].unpack1('N')
-            headers_length = chunk[(offset + 4)...(offset + 8)].unpack1('N')
-            [total_length, headers_length]
-          end
-
-          def valid_lengths?(total_length, headers_length)
-            valid_length_constraints?(total_length, headers_length)
-          end
-
-          def calculate_positions(offset, total_length, headers_length)
-            headers_end = offset + 12 + headers_length
-            payload_end = offset + total_length - 4 # Subtract 4 bytes for message CRC
-            [headers_end, payload_end]
-          end
-
-          def valid_positions?(headers_end, payload_end, chunk_size)
-            return false if headers_end >= payload_end
-            return false if headers_end >= chunk_size
-            return false if payload_end > chunk_size
-
-            true
-          end
-
-          def find_next_message(chunk, offset)
-            next_prelude = find_next_prelude(chunk, offset + 4)
-            next_prelude || chunk.bytesize
-          end
-
-          def find_next_prelude(chunk, start_offset)
-            scan_range(chunk, start_offset).each do |pos|
-              return pos if valid_prelude_at_position?(chunk, pos)
-            end
-            nil
-          end
-
-          private
-
-          def scan_range(chunk, start_offset)
-            (start_offset...(chunk.bytesize - 8))
-          end
-
-          def valid_prelude_at_position?(chunk, pos)
-            lengths = extract_potential_lengths(chunk, pos)
-            valid_length_constraints?(*lengths)
-          end
-
-          def extract_potential_lengths(chunk, pos)
-            [
-              chunk[pos...(pos + 4)].unpack1('N'),
-              chunk[(pos + 4)...(pos + 8)].unpack1('N')
-            ]
-          end
-
-          def valid_length_constraints?(total_length, headers_length)
-            return false if total_length.nil? || headers_length.nil?
-            return false if total_length <= 0 || total_length > 1_000_000
-            return false if headers_length <= 0 || headers_length >= total_length
-
-            true
-          end
-        end
-      end
-    end
-  end
-end