llm.rb 8.1.0 → 9.0.0

data/lib/llm/provider/transport/http/execution.rb

@@ -1,115 +0,0 @@
-# frozen_string_literal: true
-
-module LLM::Provider::Transport
-  class HTTP
-    ##
-    # Internal HTTP request execution methods for {LLM::Provider}.
-    #
-    # This module handles provider-side HTTP execution, response parsing,
-    # streaming, and request body setup through
-    # {LLM::Provider::Transport::HTTP}.
-    #
-    # @api private
-    module HTTP::Execution
-      private
-
-      ##
-      # Executes a HTTP request
-      # @param [Net::HTTPRequest] request
-      #  The request to send
-      # @param [Proc] b
-      #  A block to yield the response to (optional)
-      # @return [Net::HTTPResponse]
-      #  The response from the server
-      # @raise [LLM::Error::Unauthorized]
-      #  When authentication fails
-      # @raise [LLM::Error::RateLimit]
-      #  When the rate limit is exceeded
-      # @raise [LLM::Error]
-      #  When any other unsuccessful status code is returned
-      # @raise [SystemCallError]
-      #  When there is a network error at the operating system level
-      # @return [Net::HTTPResponse]
-      def execute(request:, operation:, stream: nil, stream_parser: self.stream_parser, model: nil, inputs: nil, &b)
-        owner = transport.request_owner
-        tracer = self.tracer
-        span = tracer.on_request_start(operation:, model:, inputs:)
-        res = transport.request(request, owner:) do |http|
-          perform_request(http, request, stream, stream_parser, &b)
-        end
-        [handle_response(res, tracer, span), span, tracer]
-      rescue *transport.interrupt_errors
-        raise LLM::Interrupt, "request interrupted" if transport.interrupted?(owner)
-        raise
-      end
-
-      ##
-      # Handles the response from a request
-      # @param [Net::HTTPResponse] res
-      #  The response to handle
-      # @param [Object, nil] span
-      #  The span
-      # @return [Net::HTTPResponse]
-      def handle_response(res, tracer, span)
-        case res
-        when Net::HTTPOK then res.body = parse_response(res)
-        else error_handler.new(tracer, span, res).raise_error!
-        end
-        res
-      end
-
-      ##
-      # Parse a HTTP response
-      # @param [Net::HTTPResponse] res
-      # @return [LLM::Object, String]
-      def parse_response(res)
-        case res["content-type"]
-        when %r{\Aapplication/json\s*} then LLM::Object.from(LLM.json.load(res.body))
-        else res.body
-        end
-      end
-
-      ##
-      # @param [Net::HTTPRequest] req
-      #  The request to set the body stream for
-      # @param [IO] io
-      #  The IO object to set as the body stream
-      # @return [void]
-      def set_body_stream(req, io)
-        req.body_stream = io
-        req["transfer-encoding"] = "chunked" unless req["content-length"]
-      end
-
-      ##
-      # Performs the request on the given HTTP connection.
-      # @param [Net::HTTP] http
-      # @param [Net::HTTPRequest] request
-      # @param [Object, nil] stream
-      # @param [Class] stream_parser
-      # @param [Proc, nil] b
-      # @return [Net::HTTPResponse]
-      def perform_request(http, request, stream, stream_parser, &b)
-        if stream
-          http.request(request) do |res|
-            if Net::HTTPSuccess === res
-              parser = stream_decoder.new(stream_parser.new(stream))
-              res.read_body(parser)
-              body = parser.body
-              res.body = (Hash === body || Array === body) ? LLM::Object.from(body) : body
-            else
-              body = +""
-              res.read_body { body << _1 }
-              res.body = body
-            end
-          ensure
-            parser&.free
-          end
-        elsif b
-          http.request(request) { (Net::HTTPSuccess === _1) ? b.call(_1) : _1 }
-        else
-          http.request(request)
-        end
-      end
-    end
-  end
-end

data/lib/llm/provider/transport/http/interruptible.rb

@@ -1,114 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Provider
-  ##
-  # Internal request interruption methods for
-  # {LLM::Provider::Transport::HTTP}.
-  #
-  # This module tracks active requests by execution owner and provides
-  # the logic used to interrupt an in-flight request by closing the
-  # active HTTP connection.
-  #
-  # @api private
-  module Transport::HTTP::Interruptible
-    INTERRUPT_ERRORS = [::IOError, ::EOFError, Errno::EBADF].freeze
-    Request = Struct.new(:http, :connection, keyword_init: true)
-
-    def interrupt_errors
-      [*INTERRUPT_ERRORS, *optional_interrupt_errors]
-    end
-
-    ##
-    # Interrupt an active request, if any.
-    # @param [Fiber] owner
-    #  The execution owner whose request should be interrupted
-    # @return [nil]
-    def interrupt!(owner)
-      req = request_for(owner) or return
-      lock { (@interrupts ||= {})[owner] = true }
-      if persistent_http?(req.http)
-        close_socket(req.connection&.http)
-        req.http.finish(req.connection)
-      elsif transient_http?(req.http)
-        close_socket(req.http)
-        req.http.finish if req.http.active?
-      end
-      owner.stop if owner.respond_to?(:stop)
-    rescue *interrupt_errors
-      nil
-    end
-
-    private
-
-    ##
-    # Closes the active socket for a request, if present.
-    # @param [Net::HTTP, nil] http
-    # @return [nil]
-    def close_socket(http)
-      socket = http&.instance_variable_get(:@socket) or return
-      socket = socket.io if socket.respond_to?(:io)
-      socket.close
-    rescue *interrupt_errors
-      nil
-    end
-
-    ##
-    # Returns whether the active request is using a transient HTTP client.
-    # @param [Object, nil] http
-    # @return [Boolean]
-    def transient_http?(http)
-      Net::HTTP === http
-    end
-
-    ##
-    # Returns whether the active request is using a persistent HTTP client.
-    # @param [Object, nil] http
-    # @return [Boolean]
-    def persistent_http?(http)
-      defined?(Net::HTTP::Persistent) && Net::HTTP::Persistent === http
-    end
-
-    ##
-    # Returns the active request for an execution owner.
-    # @param [Fiber] owner
-    # @return [Request, nil]
-    def request_for(owner)
-      lock do
-        @requests ||= {}
-        @requests[owner]
-      end
-    end
-
-    ##
-    # Records an active request for an execution owner.
-    # @param [Request] req
-    # @param [Fiber] owner
-    # @return [Request]
-    def set_request(req, owner)
-      lock do
-        @requests ||= {}
-        @requests[owner] = req
-      end
-    end
-
-    ##
-    # Clears the active request for an execution owner.
-    # @param [Fiber] owner
-    # @return [Request, nil]
-    def clear_request(owner)
-      lock { @requests&.delete(owner) }
-    end
-
-    ##
-    # Returns whether an execution owner was interrupted.
-    # @param [Fiber] owner
-    # @return [Boolean, nil]
-    def interrupted?(owner)
-      lock { @interrupts&.delete(owner) }
-    end
-
-    def optional_interrupt_errors
-      defined?(::Async::Stop) ? [Async::Stop] : []
-    end
-  end
-end

data/lib/llm/provider/transport/http.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-class LLM::Provider
-  module Transport
-    ##
-    # The {LLM::Provider::Transport::HTTP LLM::Provider::Transport::HTTP}
-    # class manages HTTP connections for {LLM::Provider}. It handles
-    # transient and persistent clients, tracks active requests by owner,
-    # and interrupts in-flight requests when needed.
-    #
-    # @api private
-    class HTTP
-      require_relative "http/stream_decoder"
-      require_relative "http/interruptible"
-
-      include Interruptible
-
-      ##
-      # @param [String] host
-      # @param [Integer] port
-      # @param [Integer] timeout
-      # @param [Boolean] ssl
-      # @param [Boolean] persistent
-      # @return [LLM::Provider::Transport::HTTP]
-      def initialize(host:, port:, timeout:, ssl:, persistent: false)
-        @host = host
-        @port = port
-        @timeout = timeout
-        @ssl = ssl
-        @base_uri = URI("#{ssl ? "https" : "http"}://#{host}:#{port}/")
-        @persistent_client = persistent ? persistent_client : nil
-        @monitor = Monitor.new
-      end
-
-      ##
-      # Interrupt an active request, if any.
-      # @param [Fiber] owner
-      # @return [nil]
-      def interrupt!(owner)
-        super
-      end
-
-      ##
-      # Returns whether an execution owner was interrupted.
-      # @param [Fiber] owner
-      # @return [Boolean, nil]
-      def interrupted?(owner)
-        super
-      end
-
-      ##
-      # Returns the current request owner.
-      # @return [Object]
-      def request_owner
-        return Fiber.current unless defined?(::Async)
-        Async::Task.current? ? Async::Task.current : Fiber.current
-      end
-
-      ##
-      # Configures the transport to use a persistent HTTP connection pool.
-      # @return [LLM::Provider::Transport::HTTP]
-      def persist!
-        client = persistent_client
-        lock do
-          @persistent_client = client
-          self
-        end
-      end
-      alias_method :persistent, :persist!
-
-      ##
-      # @return [Boolean]
-      def persistent?
-        !@persistent_client.nil?
-      end
-
-      ##
-      # Performs a request on the current HTTP transport.
-      # @param [Net::HTTPRequest] request
-      # @param [Fiber] owner
-      # @yieldparam [Net::HTTP] http
-      # @return [Object]
-      def request(request, owner:, &)
-        if persistent?
-          request_persistent(request, owner, &)
-        else
-          request_transient(request, owner, &)
-        end
-      ensure
-        clear_request(owner)
-      end
-
-      ##
-      # @return [String]
-      def inspect
-        "#<#{self.class.name}:0x#{object_id.to_s(16)} @persistent=#{persistent?}>"
-      end
-
-      private
-
-      attr_reader :host, :port, :timeout, :ssl, :base_uri
-
-      def request_transient(request, owner, &)
-        http = transient_client
-        set_request(Request.new(http:), owner)
-        yield http
-      end
-
-      def request_persistent(request, owner, &)
-        persistent_client.connection_for(URI.join(base_uri, request.path)) do |connection|
-          set_request(Request.new(http: persistent_client, connection:), owner)
-          yield connection.http
-        end
-      end
-
-      def persistent_client
-        LLM.lock(:clients) do
-          if LLM.clients[client_id]
-            LLM.clients[client_id]
-          else
-            require "net/http/persistent" unless defined?(Net::HTTP::Persistent)
-            client = Net::HTTP::Persistent.new(name: self.class.name)
-            client.read_timeout = timeout
-            LLM.clients[client_id] = client
-          end
-        end
-      end
-
-      def transient_client
-        client = Net::HTTP.new(host, port)
-        client.read_timeout = timeout
-        client.use_ssl = ssl
-        client
-      end
-
-      def client_id
-        "#{host}:#{port}:#{timeout}:#{ssl}"
-      end
-
-      def lock(&)
-        @monitor.synchronize(&)
-      end
-    end
-  end
-end

data/lib/llm/utils.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-##
-# @private
-module LLM::Utils
-  def camelcase(key)
-    key.to_s
-      .split("_")
-      .map.with_index { (_2 > 0) ? _1.capitalize : _1 }
-      .join
-  end
-
-  def snakecase(key)
-    key
-      .split(/([A-Z])/)
-      .map { (_1.size == 1) ? "_#{_1.downcase}" : _1 }
-      .join
-  end
-end