ruby_llm 1.16.0 → 2.0.0.rc4

data/lib/ruby_llm/streaming.rb

@@ -1,179 +0,0 @@
-# frozen_string_literal: true
-
-require 'event_stream_parser'
-require 'faraday'
-require 'json'
-
-module RubyLLM
-  # Handles streaming responses from AI providers.
-  module Streaming
-    module_function
-
-    def stream_response(connection, payload, additional_headers = {}, &block)
-      accumulator = StreamAccumulator.new
-
-      response = connection.post stream_url, payload do |req|
-        req.headers = additional_headers.merge(req.headers) unless additional_headers.empty?
-        if faraday_1?
-          req.options[:on_data] = handle_stream do |chunk|
-            accumulator.add chunk
-            block.call chunk
-          end
-        else
-          req.options.on_data = handle_stream do |chunk|
-            accumulator.add chunk
-            block.call chunk
-          end
-        end
-      end
-
-      message = accumulator.to_message(response)
-      RubyLLM.logger.debug { "Stream completed: #{message.content}" }
-      message
-    end
-
-    def handle_stream(&block)
-      build_on_data_handler do |data|
-        block.call(build_chunk(data)) if data.is_a?(Hash)
-      end
-    end
-
-    private
-
-    def faraday_1?
-      Faraday::VERSION.start_with?('1')
-    end
-
-    def build_on_data_handler(&handler)
-      buffer = +''
-      parser = EventStreamParser::Parser.new
-
-      FaradayHandlers.build(
-        faraday_v1: faraday_1?,
-        on_chunk: ->(chunk, env) { process_stream_chunk(chunk, parser, env, &handler) },
-        on_failed_response: ->(chunk, env) { handle_failed_response(chunk, buffer, env) }
-      )
-    end
-
-    def process_stream_chunk(chunk, parser, env, &)
-      RubyLLM.logger.debug { "Received chunk: #{chunk}" } if RubyLLM.config.log_stream_debug
-
-      if error_chunk?(chunk)
-        handle_error_chunk(chunk, env)
-      elsif json_error_payload?(chunk)
-        handle_json_error_chunk(chunk, env)
-      else
-        yield handle_sse(chunk, parser, env, &)
-      end
-    end
-
-    def error_chunk?(chunk)
-      chunk.start_with?('event: error')
-    end
-
-    def json_error_payload?(chunk)
-      chunk.lstrip.start_with?('{') && chunk.include?('"error"')
-    end
-
-    def handle_json_error_chunk(chunk, env)
-      parse_error_from_json(chunk, env, 'Failed to parse JSON error chunk')
-    end
-
-    def handle_error_chunk(chunk, env)
-      error_data = chunk.split("\n")[1].delete_prefix('data: ')
-      parse_error_from_json(error_data, env, 'Failed to parse error chunk')
-    end
-
-    def handle_failed_response(chunk, buffer, env)
-      buffer << chunk
-      error_data = JSON.parse(buffer)
-      handle_parsed_error(error_data, env)
-    rescue JSON::ParserError
-      RubyLLM.logger.debug { "Accumulating error chunk: #{chunk}" }
-    end
-
-    def handle_sse(chunk, parser, env, &block)
-      parser.feed(chunk) do |type, data|
-        case type.to_sym
-        when :error
-          handle_error_event(data, env)
-        else
-          yield handle_data(data, env, &block) unless data == '[DONE]'
-        end
-      end
-    end
-
-    def handle_data(data, env)
-      parsed = JSON.parse(data)
-      return parsed unless parsed.is_a?(Hash) && parsed.key?('error')
-
-      handle_parsed_error(parsed, env)
-    rescue JSON::ParserError => e
-      RubyLLM.logger.debug { "Failed to parse data chunk: #{e.message}" }
-    end
-
-    def handle_error_event(data, env)
-      parse_error_from_json(data, env, 'Failed to parse error event')
-    end
-
-    def parse_streaming_error(data)
-      error_data = JSON.parse(data)
-      [500, error_data['message'] || 'Unknown streaming error']
-    rescue JSON::ParserError => e
-      RubyLLM.logger.debug { "Failed to parse streaming error: #{e.message}" }
-      [500, "Failed to parse error: #{data}"]
-    end
-
-    def handle_parsed_error(parsed_data, env)
-      status, _message = parse_streaming_error(parsed_data.to_json)
-      error_response = build_stream_error_response(parsed_data, env, status)
-      ErrorMiddleware.parse_error(provider: self, response: error_response)
-    end
-
-    def parse_error_from_json(data, env, error_message)
-      parsed_data = JSON.parse(data)
-      handle_parsed_error(parsed_data, env)
-    rescue JSON::ParserError => e
-      RubyLLM.logger.debug { "#{error_message}: #{e.message}" }
-    end
-
-    def build_stream_error_response(parsed_data, env, status)
-      error_status = status || env&.status || 500
-
-      if faraday_1?
-        Struct.new(:body, :status).new(parsed_data, error_status)
-      else
-        env.merge(body: parsed_data, status: error_status)
-      end
-    end
-
-    # Builds Faraday on_data handlers for different major versions.
-    module FaradayHandlers
-      module_function
-
-      def build(faraday_v1:, on_chunk:, on_failed_response:)
-        if faraday_v1
-          v1_on_data(on_chunk)
-        else
-          v2_on_data(on_chunk, on_failed_response)
-        end
-      end
-
-      def v1_on_data(on_chunk)
-        proc do |chunk, _size|
-          on_chunk.call(chunk, nil)
-        end
-      end
-
-      def v2_on_data(on_chunk, on_failed_response)
-        proc do |chunk, _bytes, env|
-          if env&.status == 200
-            on_chunk.call(chunk, env)
-          else
-            on_failed_response.call(chunk, env)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/tool_concurrency.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  # Runs multiple tool calls concurrently with Ruby's built-in threads or optional fibers.
-  module ToolConcurrency
-    MODES = %i[threads fibers].freeze
-    Result = Struct.new(:index, :tool_call, :value, :error, keyword_init: true)
-
-    module_function
-
-    def modes
-      MODES
-    end
-
-    def supported?(name)
-      MODES.include?(name)
-    end
-
-    def run(mode, tool_calls, on_result: nil, &)
-      case mode
-      when :threads
-        run_with_threads(tool_calls, on_result:, &)
-      when :fibers
-        run_with_fibers(tool_calls, on_result:, &)
-      end
-    end
-
-    def run_with_threads(tool_calls, on_result:, &execute)
-      executor = rails_executor
-      queue = Queue.new
-      threads = tool_calls.each_value.with_index.map do |tool_call, index|
-        thread = Thread.new { queue << capture_result(index, tool_call, executor, execute) }
-        thread.report_on_exception = false
-        thread
-      end
-
-      collect_results(queue, threads.size, on_result:)
-    ensure
-      threads&.each(&:join)
-    end
-
-    def run_with_fibers(tool_calls, on_result:, &execute)
-      begin
-        require 'async'
-        require 'async/queue'
-      rescue LoadError
-        raise LoadError, "The 'async' gem is required for concurrent tool execution with fibers. " \
-                         "Add `gem 'async'` to your Gemfile or use `concurrency: :threads`."
-      end
-
-      executor = rails_executor
-      Async do |task|
-        queue = Async::Queue.new
-        tasks = tool_calls.each_value.with_index.map do |tool_call, index|
-          task.async { queue << capture_result(index, tool_call, executor, execute) }
-        end
-
-        collect_results(queue, tasks.size, on_result:)
-      ensure
-        tasks&.each(&:wait)
-      end.wait
-    end
-
-    def collect_results(queue, count, on_result:)
-      results = Array.new(count)
-      errors = []
-
-      count.times do
-        result = queue.pop
-        if result.error
-          errors << result.error
-        else
-          results[result.index] = [result.tool_call, result.value]
-          on_result&.call(result.tool_call, result.value)
-        end
-      end
-
-      raise errors.first if errors.any?
-
-      results
-    end
-
-    def capture_result(index, tool_call, rails_executor, execute)
-      tool_call, value = run_tool_call(tool_call, rails_executor, execute)
-      Result.new(index:, tool_call:, value:)
-    rescue Exception => e # rubocop:disable Lint/RescueException
-      Result.new(index:, tool_call:, error: e)
-    end
-
-    def run_tool_call(tool_call, rails_executor, execute)
-      if rails_executor
-        rails_executor.wrap { [tool_call, execute.call(tool_call)] }
-      else
-        [tool_call, execute.call(tool_call)]
-      end
-    end
-
-    def rails_executor
-      defined?(Rails) && Rails.respond_to?(:application) && Rails.application&.executor
-    end
-
-    private_class_method :run_with_threads, :run_with_fibers, :collect_results, :capture_result, :run_tool_call,
-                         :rails_executor
-  end
-end

data/lib/ruby_llm/utils.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  # Provides utility functions for data manipulation within the RubyLLM library
-  module Utils
-    module_function
-
-    def hash_get(hash, key)
-      hash[key.to_sym] || hash[key.to_s]
-    end
-
-    def to_safe_array(item)
-      case item
-      when Array
-        item
-      when Hash
-        [item]
-      else
-        Array(item)
-      end
-    end
-
-    def to_time(value)
-      return unless value
-
-      value.is_a?(Time) ? value : Time.parse(value.to_s)
-    end
-
-    def to_date(value)
-      return unless value
-
-      value.is_a?(Date) ? value : Date.parse(value.to_s)
-    end
-
-    def safe_constantize(name)
-      parts = name.to_s.split('::').reject(&:empty?)
-      return if parts.empty?
-
-      namespace = Object
-      until parts.empty?
-        const_name = parts.shift
-        return unless namespace.const_defined?(const_name, false)
-
-        namespace = namespace.const_get(const_name, false)
-      end
-      namespace
-    rescue NameError
-      nil
-    end
-
-    def parse_iso_date_prefix(value)
-      return value if value.is_a?(Date)
-
-      date = value.to_s.strip
-      return if date.empty?
-
-      case date
-      when /\A\d{4}-\d{2}-\d{2}\z/
-        Date.iso8601(date)
-      when /\A\d{4}-\d{2}\z/
-        Date.iso8601("#{date}-01")
-      when /\A\d{4}\z/
-        Date.iso8601("#{date}-01-01")
-      end
-    rescue ArgumentError
-      nil
-    end
-
-    def iso_date_prefix_to_utc_midnight_string(value)
-      date = parse_iso_date_prefix(value)
-      "#{date.strftime('%Y-%m-%d')} 00:00:00 UTC" if date
-    end
-
-    def deep_merge(original, overrides)
-      original.merge(overrides) do |_key, original_value, overrides_value|
-        if original_value.is_a?(Hash) && overrides_value.is_a?(Hash)
-          deep_merge(original_value, overrides_value)
-        else
-          overrides_value
-        end
-      end
-    end
-
-    def deep_dup(value)
-      case value
-      when Hash
-        value.each_with_object({}) do |(key, val), duped|
-          duped[deep_dup(key)] = deep_dup(val)
-        end
-      when Array
-        value.map { |item| deep_dup(item) }
-      else
-        begin
-          value.dup
-        rescue TypeError
-          value
-        end
-      end
-    end
-
-    def deep_stringify_keys(value)
-      case value
-      when Hash
-        value.each_with_object({}) do |(key, val), result|
-          result[key.to_s] = deep_stringify_keys(val)
-        end
-      when Array
-        value.map { |item| deep_stringify_keys(item) }
-      when Symbol
-        value.to_s
-      else
-        value
-      end
-    end
-
-    def deep_symbolize_keys(value)
-      case value
-      when Hash
-        value.each_with_object({}) do |(key, val), result|
-          symbolized_key = key.respond_to?(:to_sym) ? key.to_sym : key
-          result[symbolized_key] = deep_symbolize_keys(val)
-        end
-      when Array
-        value.map { |item| deep_symbolize_keys(item) }
-      else
-        value
-      end
-    end
-  end
-end