simple_inference 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 324b5bd8986fee7b2130229b1bb7ad277b1c476c71ed07c5a350845f91ae23a5
-  data.tar.gz: b746716fe0e9364bf1085acc4ac2a09dfe6ca5703831562869a96fdf43ea29a2
+  metadata.gz: c062a86e32995fae41fc56269622856569f8bf3e77a1a25be45697ca008332e8
+  data.tar.gz: 1988b5edc14d9c3b83963cb34a9aa75a9bea5595511fb00b8668187826aa1d74
 SHA512:
-  metadata.gz: 25baf84b1d22f57ed1ccb4b0413acf79cad258efee5e2a31b33d6a0247a87b175492cf293a67c6c7c2503c7d3c28e32283e21dba1aeb1bcbbe621203975e7972
-  data.tar.gz: ba78fc2c974118d4046119cc378202556e3d50611514df0cb4a9affa41412c5bb1a77aeccaef34071de15792a63b17bb5f484cafec8f506f7372660ba09fc5fa
+  metadata.gz: 0fb7c8c961caba0f69765d06d51f528decfbc5ec8c4cd42cbdf3a32ef109b4ff43ea155e75ec60712638f01d43589ff933a14baba80d08ed807f0d701a818f26
+  data.tar.gz: cedbee5acc803c8aa8e915aad28857a7d369bba100aa00c73f9843b53f0c41d90ccf199380a1af768831125fbce59f0d991f86b44d3d1c8ac6f184d45edf6716

data/README.md

@@ -224,6 +224,8 @@ The default HTTP adapter uses Ruby's `Net::HTTP` and is safe to use under Puma's
 - Per-client configuration only
 - Blocking IO that integrates with Ruby 3 Fiber scheduler
 
+If you don't pass an adapter, `SimpleInference::Client` uses `SimpleInference::HTTPAdapters::Default` (Net::HTTP).
+
 For Falcon / async environments, you can keep the default adapter, or use the optional HTTPX adapter (requires the `httpx` gem):
 
 ```ruby
@@ -233,7 +235,7 @@ gem "httpx" # optional, only required when using the HTTPX adapter
 You can then use the optional HTTPX adapter shipped with this gem:
 
 ```ruby
-adapter = SimpleInference::HTTPAdapter::HTTPX.new(timeout: 30.0)
+adapter = SimpleInference::HTTPAdapters::HTTPX.new(timeout: 30.0)
 
 SIMPLE_INFERENCE_CLIENT =
   SimpleInference::Client.new(

data/lib/simple_inference/client.rb

@@ -12,7 +12,12 @@ module SimpleInference
 
     def initialize(options = {})
       @config = Config.new(options || {})
-      @adapter = @config.adapter || HTTPAdapter::Default.new
+      @adapter = @config.adapter || HTTPAdapters::Default.new
+
+      unless @adapter.is_a?(HTTPAdapter)
+        raise Errors::ConfigurationError,
+              "adapter must be an instance of SimpleInference::HTTPAdapter (got #{@adapter.class})"
+      end
     end
 
     # POST /v1/chat/completions
@@ -168,32 +173,15 @@ module SimpleInference
     def handle_stream_response(request_env, raise_on_http_error:, &on_event)
       sse_buffer = +""
       sse_done = false
-      used_streaming_adapter = false
+      streamed = false
 
       raw_response =
-        if @adapter.respond_to?(:call_stream)
-          used_streaming_adapter = true
-          @adapter.call_stream(request_env) do |chunk|
-            next if sse_done
-
-            sse_buffer << chunk.to_s
-            extract_sse_blocks!(sse_buffer).each do |block|
-              data = sse_data_from_block(block)
-              next if data.nil?
-
-              payload = data.strip
-              next if payload.empty?
-              if payload == "[DONE]"
-                sse_done = true
-                sse_buffer.clear
-                break
-              end
-
-              on_event&.call(parse_json_event(payload))
-            end
-          end
-        else
-          @adapter.call(request_env)
+        @adapter.call_stream(request_env) do |chunk|
+          streamed = true
+          next if sse_done
+
+          sse_buffer << chunk.to_s
+          sse_done = consume_sse_buffer!(sse_buffer, &on_event) || sse_done
         end
 
       status = raw_response[:status]
@@ -206,18 +194,9 @@ module SimpleInference
       # Streaming case.
       if status >= 200 && status < 300 && content_type.include?("text/event-stream")
         # If we couldn't stream incrementally, best-effort parse the full SSE body.
-        unless used_streaming_adapter
+        unless streamed
           buffer = body_str.dup
-          extract_sse_blocks!(buffer).each do |block|
-            data = sse_data_from_block(block)
-            next if data.nil?
-
-            payload = data.strip
-            next if payload.empty?
-            break if payload == "[DONE]"
-
-            on_event&.call(parse_json_event(payload))
-          end
+          consume_sse_buffer!(buffer, &on_event)
         end
 
         return {
@@ -231,39 +210,14 @@ module SimpleInference
       should_parse_json = content_type.include?("json")
       parsed_body = should_parse_json ? parse_json(body_str) : body_str
 
-      raise_on =
-        if raise_on_http_error.nil?
-          config.raise_on_error
-        else
-          !!raise_on_http_error
-        end
-
-      if raise_on && (status < 200 || status >= 300)
-        # Do not raise for the known "streaming unsupported" case; the caller will
-        # perform a non-streaming retry fallback.
-        unless streaming_unsupported_error?(status, parsed_body)
-          message = "HTTP #{status}"
-          begin
-            error_body = JSON.parse(body_str)
-            error_field = error_body["error"]
-            message =
-              if error_field.is_a?(Hash)
-                error_field["message"] || error_body["message"] || message
-              else
-                error_field || error_body["message"] || message
-              end
-          rescue JSON::ParserError
-            # fall back to generic message
-          end
-
-          raise Errors::HTTPError.new(
-            message,
-            status: status,
-            headers: headers,
-            body: body_str
-          )
-        end
-      end
+      maybe_raise_http_error(
+        status: status,
+        headers: headers,
+        body_str: body_str,
+        raise_on_http_error: raise_on_http_error,
+        ignore_streaming_unsupported: true,
+        parsed_body: parsed_body
+      )
 
       {
         status: status,
@@ -294,6 +248,27 @@ module SimpleInference
       blocks
     end
 
+    def consume_sse_buffer!(buffer, &on_event)
+      done = false
+
+      extract_sse_blocks!(buffer).each do |block|
+        data = sse_data_from_block(block)
+        next if data.nil?
+
+        payload = data.strip
+        next if payload.empty?
+        if payload == "[DONE]"
+          done = true
+          buffer.clear
+          break
+        end
+
+        on_event&.call(parse_json_event(payload))
+      end
+
+      done
+    end
+
     def sse_data_from_block(block)
       return nil if block.nil? || block.empty?
 
@@ -426,6 +401,7 @@ module SimpleInference
       end
 
       body, headers = build_multipart_body(io, filename, form_fields)
+      headers["Transfer-Encoding"] = "chunked" if body.respond_to?(:size) && body.size.nil?
 
       request_env = {
         method: :post,
@@ -481,60 +457,130 @@ module SimpleInference
         "Content-Type" => "multipart/form-data; boundary=#{boundary}",
       }
 
-      body = +""
-
+      parts = []
       fields.each do |name, value|
-        body << "--#{boundary}\r\n"
-        body << %(Content-Disposition: form-data; name="#{name}"\r\n\r\n)
-        body << value.to_s
-        body << "\r\n"
+        parts << "--#{boundary}\r\n".b
+        parts << %(Content-Disposition: form-data; name="#{name}"\r\n\r\n).b
+        parts << value.to_s.b
+        parts << "\r\n".b
       end
 
-      body << "--#{boundary}\r\n"
-      body << %(Content-Disposition: form-data; name="file"; filename="#{filename}"\r\n)
-      body << "Content-Type: application/octet-stream\r\n\r\n"
+      parts << "--#{boundary}\r\n".b
+      parts << %(Content-Disposition: form-data; name="file"; filename="#{filename}"\r\n).b
+      parts << "Content-Type: application/octet-stream\r\n\r\n".b
+      parts << io
+      parts << "\r\n--#{boundary}--\r\n".b
 
-      while (chunk = io.read(16_384))
-        body << chunk
+      [MultipartStream.new(parts), headers]
+    end
+
+    class MultipartStream
+      def initialize(parts)
+        @parts = parts
+        @part_index = 0
+        @string_offset = 0
+        @size = nil
       end
 
-      body << "\r\n--#{boundary}--\r\n"
+      def read(length = nil, outbuf = nil)
+        return "".b if length.nil? && eof?
+        return nil if eof?
 
-      [body, headers]
-    end
+        out = outbuf ? outbuf.replace("".b) : +"".b
 
-    def handle_response(request_env, expect_json:, raise_on_http_error:)
-      response = @adapter.call(request_env)
+        if length.nil?
+          while (chunk = read(16_384))
+            out << chunk
+          end
+          return out
+        end
 
-      status = response[:status]
-      headers = (response[:headers] || {}).transform_keys { |k| k.to_s.downcase }
-      body = response[:body].to_s
+        while out.bytesize < length && !eof?
+          part = @parts.fetch(@part_index)
 
-      # Decide whether to raise on HTTP errors
-      raise_on =
-        if raise_on_http_error.nil?
-          config.raise_on_error
-        else
-          !!raise_on_http_error
+          if part.is_a?(String)
+            remaining = part.bytesize - @string_offset
+            if remaining <= 0
+              advance_part!
+              next
+            end
+
+            take = [length - out.bytesize, remaining].min
+            out << part.byteslice(@string_offset, take)
+            @string_offset += take
+
+            advance_part! if @string_offset >= part.bytesize
+          else
+            chunk = part.read(length - out.bytesize)
+            if chunk.nil? || chunk.empty?
+              advance_part!
+              next
+            end
+
+            out << chunk
+          end
         end
 
-      if raise_on && (status < 200 || status >= 300)
-        message = "HTTP #{status}"
+        return nil if out.empty? && eof?
 
-        begin
-          error_body = JSON.parse(body)
-          message = error_body["error"] || error_body["message"] || message
-        rescue JSON::ParserError
-          # fall back to generic message
+        out
+      end
+
+      def size
+        @size ||= compute_size
+      end
+
+      private
+
+      def eof?
+        @part_index >= @parts.length
+      end
+
+      def advance_part!
+        @part_index += 1
+        @string_offset = 0
+      end
+
+      def compute_size
+        total = 0
+
+        @parts.each do |part|
+          if part.is_a?(String)
+            total += part.bytesize
+            next
+          end
+
+          return nil unless part.respond_to?(:size)
+
+          part_size = part.size
+          if part.respond_to?(:pos)
+            begin
+              part_size -= part.pos
+            rescue StandardError
+              # ignore pos errors
+            end
+          end
+
+          total += part_size
         end
 
-        raise Errors::HTTPError.new(
-          message,
-          status: status,
-          headers: headers,
-          body: body
-        )
+        total
       end
+    end
+
+    def handle_response(request_env, expect_json:, raise_on_http_error:)
+      response = @adapter.call(request_env)
+
+      status = response[:status]
+      headers = (response[:headers] || {}).transform_keys { |k| k.to_s.downcase }
+      body = response[:body].to_s
+
+      maybe_raise_http_error(
+        status: status,
+        headers: headers,
+        body_str: body,
+        raise_on_http_error: raise_on_http_error
+      )
 
       should_parse_json =
         if expect_json.nil?
@@ -569,5 +615,56 @@ module SimpleInference
     rescue JSON::ParserError => e
       raise Errors::DecodeError, "Failed to parse JSON response: #{e.message}"
     end
+
+    def raise_on_http_error?(raise_on_http_error)
+      raise_on_http_error.nil? ? config.raise_on_error : !!raise_on_http_error
+    end
+
+    def http_error_message(status, body_str, parsed_body: nil)
+      message = "HTTP #{status}"
+
+      error_body =
+        if parsed_body.is_a?(Hash)
+          parsed_body
+        else
+          begin
+            JSON.parse(body_str)
+          rescue JSON::ParserError
+            nil
+          end
+        end
+
+      return message unless error_body.is_a?(Hash)
+
+      error_field = error_body["error"]
+      if error_field.is_a?(Hash)
+        error_field["message"] || error_body["message"] || message
+      else
+        error_field || error_body["message"] || message
+      end
+    end
+
+    def maybe_raise_http_error(
+      status:,
+      headers:,
+      body_str:,
+      raise_on_http_error:,
+      ignore_streaming_unsupported: false,
+      parsed_body: nil
+    )
+      return unless raise_on_http_error?(raise_on_http_error)
+      return unless status < 200 || status >= 300
+
+      # Do not raise for the known "streaming unsupported" case; the caller will
+      # perform a non-streaming retry fallback.
+      return if ignore_streaming_unsupported && streaming_unsupported_error?(status, parsed_body)
+
+      raise Errors::HTTPError.new(
+        http_error_message(status, body_str, parsed_body: parsed_body),
+        status: status,
+        headers: headers,
+        body: body_str
+      )
+    end
   end
 end

data/lib/simple_inference/http_adapter.rb

@@ -1,123 +1,44 @@
 # frozen_string_literal: true
 
-require "net/http"
-require "uri"
-
 module SimpleInference
-  module HTTPAdapter
-    # Optional adapters are lazily loaded so the SDK has no hard runtime deps.
-    autoload :HTTPX, "simple_inference/http_adapter/httpx"
-
-    # Default synchronous HTTP adapter built on Net::HTTP.
-    # It is compatible with Ruby 3 Fiber scheduler and keeps the interface
-    # minimal so it can be swapped out for custom adapters (HTTPX, async-http, etc.).
-    class Default
-      def call(request)
-        uri = URI.parse(request.fetch(:url))
-
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == "https"
-
-        timeout = request[:timeout]
-        open_timeout = request[:open_timeout] || timeout
-        read_timeout = request[:read_timeout] || timeout
-
-        http.open_timeout = open_timeout if open_timeout
-        http.read_timeout = read_timeout if read_timeout
-
-        klass = http_class_for(request[:method])
-        req = klass.new(uri.request_uri)
-
-        headers = request[:headers] || {}
-        headers.each do |key, value|
-          req[key.to_s] = value
-        end
-
-        body = request[:body]
-        req.body = body if body
-
-        response = http.request(req)
-
-        {
-          status: Integer(response.code),
-          headers: response.each_header.to_h,
-          body: response.body.to_s,
-        }
-      end
-
-      # Streaming-capable request helper.
-      #
-      # When the response is `text/event-stream` (and 2xx), it yields raw body chunks
-      # as they arrive via the given block, and returns a response hash with `body: nil`.
-      #
-      # For non-streaming responses, it behaves like `#call` and returns the full body.
-      def call_stream(request)
-        return call(request) unless block_given?
-
-        uri = URI.parse(request.fetch(:url))
-
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == "https"
-
-        timeout = request[:timeout]
-        open_timeout = request[:open_timeout] || timeout
-        read_timeout = request[:read_timeout] || timeout
-
-        http.open_timeout = open_timeout if open_timeout
-        http.read_timeout = read_timeout if read_timeout
-
-        klass = http_class_for(request[:method])
-        req = klass.new(uri.request_uri)
-
-        headers = request[:headers] || {}
-        headers.each do |key, value|
-          req[key.to_s] = value
-        end
-
-        body = request[:body]
-        req.body = body if body
-
-        status = nil
-        response_headers = {}
-        response_body = +""
-
-        http.request(req) do |response|
-          status = Integer(response.code)
-          response_headers = response.each_header.to_h
-
-          headers_lc = response_headers.transform_keys { |k| k.to_s.downcase }
-          content_type = headers_lc["content-type"]
-
-          if status >= 200 && status < 300 && content_type&.include?("text/event-stream")
-            response.read_body do |chunk|
-              yield chunk
-            end
-            response_body = nil
-          else
-            response_body = response.body.to_s
-          end
-        end
+  # Base class for HTTP adapters.
+  #
+  # Concrete adapters must implement `#call` and may override `#call_stream`
+  # for incremental streaming.
+  class HTTPAdapter
+    def call(_request)
+      raise NotImplementedError, "#{self.class} must implement #call"
+    end
 
-        {
-          status: Integer(status),
-          headers: response_headers,
-          body: response_body,
-        }
+    # Streaming-capable request helper.
+    #
+    # When the response is `text/event-stream` (and 2xx), it yields raw body chunks
+    # as they arrive via the given block, and returns a response hash with `body: nil`.
+    #
+    # For non-streaming responses, it behaves like `#call` and returns the full body.
+    def call_stream(request)
+      return call(request) unless block_given?
+
+      response = call(request)
+
+      status = response[:status].to_i
+      headers = response[:headers] || {}
+      content_type =
+        headers.each_with_object({}) do |(k, v), out|
+          out[k.to_s.downcase] = v
+        end["content-type"].to_s
+
+      if status >= 200 && status < 300 && content_type.include?("text/event-stream")
+        yield response[:body].to_s
+        return { status: status, headers: headers, body: nil }
       end
 
-      private
-
-      def http_class_for(method)
-        case method.to_s.upcase
-        when "GET"    then Net::HTTP::Get
-        when "POST"   then Net::HTTP::Post
-        when "PUT"    then Net::HTTP::Put
-        when "PATCH"  then Net::HTTP::Patch
-        when "DELETE" then Net::HTTP::Delete
-        else
-          raise ArgumentError, "Unsupported HTTP method: #{method.inspect}"
-        end
-      end
+      response
     end
   end
+
+  module HTTPAdapters
+    autoload :Default, "simple_inference/http_adapters/default"
+    autoload :HTTPX, "simple_inference/http_adapters/httpx"
+  end
 end

data/lib/simple_inference/http_adapters/default.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module SimpleInference
+  module HTTPAdapters
+    # Default synchronous HTTP adapter built on Net::HTTP.
+    # It is compatible with Ruby 3 Fiber scheduler and keeps the interface
+    # minimal so it can be swapped out for custom adapters (HTTPX, async-http, etc.).
+    class Default < HTTPAdapter
+      def call(request)
+        http, req = build_request(request)
+
+        response = http.request(req)
+
+        {
+          status: Integer(response.code),
+          headers: response.each_header.to_h,
+          body: response.body.to_s,
+        }
+      end
+
+      # Streaming-capable request helper.
+      #
+      # When the response is `text/event-stream` (and 2xx), it yields raw body chunks
+      # as they arrive via the given block, and returns a response hash with `body: nil`.
+      #
+      # For non-streaming responses, it behaves like `#call` and returns the full body.
+      def call_stream(request)
+        return call(request) unless block_given?
+
+        http, req = build_request(request)
+
+        status = nil
+        response_headers = {}
+        response_body = +""
+
+        http.request(req) do |response|
+          status = Integer(response.code)
+          response_headers = response.each_header.to_h
+
+          headers_lc = response_headers.transform_keys { |k| k.to_s.downcase }
+          content_type = headers_lc["content-type"]
+
+          if status >= 200 && status < 300 && content_type&.include?("text/event-stream")
+            response.read_body do |chunk|
+              yield chunk
+            end
+            response_body = nil
+          else
+            response_body = response.body.to_s
+          end
+        end
+
+        {
+          status: Integer(status),
+          headers: response_headers,
+          body: response_body,
+        }
+      end
+
+      private
+
+      def build_request(request)
+        uri = URI.parse(request.fetch(:url))
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+
+        apply_timeouts(http, request)
+
+        req = http_class_for(request[:method]).new(uri.request_uri)
+        apply_headers(req, request[:headers] || {})
+        apply_body(req, request[:body])
+
+        [http, req]
+      end
+
+      def apply_timeouts(http, request)
+        timeout = request[:timeout]
+        open_timeout = request[:open_timeout] || timeout
+        read_timeout = request[:read_timeout] || timeout
+
+        http.open_timeout = open_timeout if open_timeout
+        http.read_timeout = read_timeout if read_timeout
+      end
+
+      def apply_headers(req, headers)
+        headers.each do |key, value|
+          req[key.to_s] = value
+        end
+      end
+
+      def apply_body(req, body)
+        return unless body
+
+        if body.is_a?(String)
+          req.body = body
+        elsif body.respond_to?(:read)
+          req.body_stream = body
+          if body.respond_to?(:size) && (size = body.size)
+            req.content_length = size
+            req.delete("Transfer-Encoding")
+          else
+            req["Transfer-Encoding"] = "chunked"
+          end
+        else
+          req.body = body.to_s
+        end
+      end
+
+      def http_class_for(method)
+        case method.to_s.upcase
+        when "GET"    then Net::HTTP::Get
+        when "POST"   then Net::HTTP::Post
+        when "PUT"    then Net::HTTP::Put
+        when "PATCH"  then Net::HTTP::Patch
+        when "DELETE" then Net::HTTP::Delete
+        else
+          raise ArgumentError, "Unsupported HTTP method: #{method.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/simple_inference/http_adapters/httpx.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+begin
+  require "httpx"
+rescue LoadError => e
+  raise LoadError,
+        "httpx gem is required for SimpleInference::HTTPAdapters::HTTPX (add `gem \"httpx\"`)",
+        cause: e
+end
+
+# HTTPX's stream plugin expects all request objects to respond to `#stream`,
+# however some internal requests (e.g. proxy CONNECT) don't include the plugin's
+# RequestMethods. Add a harmless accessor at the base class level.
+unless ::HTTPX::Request.method_defined?(:stream) && ::HTTPX::Request.method_defined?(:stream=)
+  ::HTTPX::Request.class_eval do
+    attr_accessor :stream
+  end
+end
+
+module SimpleInference
+  module HTTPAdapters
+    # Fiber-friendly HTTP adapter built on HTTPX.
+    class HTTPX < HTTPAdapter
+      def initialize(timeout: nil, client: ::HTTPX)
+        @timeout = timeout
+
+        unless client == ::HTTPX || client.is_a?(::HTTPX::Session)
+          raise ArgumentError,
+                "client must be ::HTTPX or an instance of ::HTTPX::Session (got #{client.class})"
+        end
+
+        @client = client
+        @stream_client = client.plugin(:stream)
+      end
+
+      def call(request)
+        method = request.fetch(:method).to_s.downcase.to_sym
+        url = request.fetch(:url)
+        headers = request[:headers] || {}
+        body = request[:body]
+
+        client = @client
+
+        # Mirror the SDK's timeout semantics:
+        # - `:timeout` is the overall request deadline (maps to HTTPX `request_timeout`)
+        # - `:open_timeout` and `:read_timeout` override connect/read deadlines
+        timeout = request[:timeout] || @timeout
+        open_timeout = request[:open_timeout] || timeout
+        read_timeout = request[:read_timeout] || timeout
+
+        timeout_opts = {}
+        timeout_opts[:request_timeout] = timeout.to_f if timeout
+        timeout_opts[:connect_timeout] = open_timeout.to_f if open_timeout
+        timeout_opts[:read_timeout] = read_timeout.to_f if read_timeout
+
+        unless timeout_opts.empty?
+          client = client.with(timeout: timeout_opts)
+        end
+
+        response = client.request(method, url, headers: headers, body: body)
+
+        # HTTPX may return an error response object instead of raising.
+        #
+        # NOTE: Some error response objects do not expose the normal response API
+        # (e.g. no `#headers`), so we must handle them explicitly.
+        if response.is_a?(::HTTPX::ErrorResponse)
+          raise Errors::ConnectionError, (response.error&.message || "HTTPX request failed")
+        end
+
+        if response.status.to_i == 0
+          raise Errors::ConnectionError, "HTTPX request failed"
+        end
+
+        response_headers = normalize_headers(response)
+
+        {
+          status: response.status.to_i,
+          headers: response_headers,
+          body: response.body.to_s,
+        }
+      rescue ::HTTPX::TimeoutError => e
+        raise Errors::TimeoutError, e.message
+      rescue ::HTTPX::Error, IOError, SystemCallError => e
+        raise Errors::ConnectionError, e.message
+      end
+
+      def call_stream(request)
+        return call(request) unless block_given?
+
+        method = request.fetch(:method).to_s.downcase.to_sym
+        url = request.fetch(:url)
+        headers = request[:headers] || {}
+        body = request[:body]
+
+        # Mirror the SDK's timeout semantics:
+        # - `:timeout` is the overall request deadline (maps to HTTPX `request_timeout`)
+        # - `:open_timeout` and `:read_timeout` override connect/read deadlines
+        timeout = request[:timeout] || @timeout
+        open_timeout = request[:open_timeout] || timeout
+        read_timeout = request[:read_timeout] || timeout
+
+        # The HTTPX stream plugin defaults to `read_timeout: Infinity`; align with the
+        # non-streaming defaults unless the caller explicitly overrides.
+        read_timeout ||= 60
+
+        timeout_opts = {}
+        timeout_opts[:request_timeout] = timeout.to_f if timeout
+        timeout_opts[:connect_timeout] = open_timeout.to_f if open_timeout
+        timeout_opts[:read_timeout] = read_timeout.to_f if read_timeout
+
+        stream_client = @stream_client
+        client =
+          if timeout_opts.empty?
+            stream_client.with(timeout: {})
+          else
+            stream_client.with(timeout: timeout_opts)
+          end
+
+        streaming = nil
+        response_headers = {}
+        status = nil
+        full_body = +"".b
+
+        stream_response = client.request(method, url, headers: headers, body: body, stream: true)
+
+        if stream_response.is_a?(::HTTPX::ErrorResponse)
+          raise Errors::ConnectionError, (stream_response.error&.message || "HTTPX request failed")
+        end
+
+        if stream_response.status.to_i == 0
+          raise Errors::ConnectionError, "HTTPX request failed"
+        end
+
+        begin
+          stream_response.each do |chunk|
+            status ||= stream_response.status.to_i
+            response_headers = normalize_headers(stream_response) if response_headers.empty?
+            streaming = streamable_sse?(status, response_headers) if streaming.nil?
+
+            if streaming
+              yield chunk
+            else
+              full_body << chunk.to_s
+            end
+          end
+        rescue ::HTTPX::HTTPError => e
+          # HTTPX's stream plugin raises for non-2xx. Swallow it and let the SDK
+          # raise `Errors::HTTPError` based on status.
+          status ||= e.response.status.to_i
+          response_headers = normalize_headers(e.response) if response_headers.empty?
+        end
+
+        status ||= stream_response.status.to_i
+        response_headers = normalize_headers(stream_response) if response_headers.empty?
+
+        if streamable_sse?(status, response_headers)
+          { status: status, headers: response_headers, body: nil }
+        else
+          { status: status, headers: response_headers, body: full_body.to_s }
+        end
+      rescue ::HTTPX::TimeoutError => e
+        raise Errors::TimeoutError, e.message
+      rescue ::HTTPX::Error, IOError, SystemCallError => e
+        raise Errors::ConnectionError, e.message
+      end
+
+      private
+
+      def normalize_headers(response)
+        response.headers.to_h.each_with_object({}) do |(k, v), out|
+          out[k.to_s] = v.is_a?(Array) ? v.join(", ") : v.to_s
+        end
+      end
+
+      def streamable_sse?(status, headers)
+        return false unless status.to_i >= 200 && status.to_i < 300
+
+        content_type =
+          headers.each_with_object({}) do |(k, v), out|
+            out[k.to_s.downcase] = v
+          end["content-type"].to_s
+
+        content_type.include?("text/event-stream")
+      end
+    end
+  end
+end

data/lib/simple_inference/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleInference
-  VERSION = "0.1.0"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple_inference
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - jasl
@@ -25,7 +25,8 @@ files:
 - lib/simple_inference/config.rb
 - lib/simple_inference/errors.rb
 - lib/simple_inference/http_adapter.rb
-- lib/simple_inference/http_adapter/httpx.rb
+- lib/simple_inference/http_adapters/default.rb
+- lib/simple_inference/http_adapters/httpx.rb
 - lib/simple_inference/version.rb
 - sig/simple_inference.rbs
 homepage: https://github.com/jasl/simple_inference_server/tree/main/sdks/ruby

data/lib/simple_inference/http_adapter/httpx.rb

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require "httpx"
-rescue LoadError => e
-  raise LoadError,
-        "httpx gem is required for SimpleInference::HTTPAdapter::HTTPX (add `gem \"httpx\"`)",
-        cause: e
-end
-
-module SimpleInference
-  module HTTPAdapter
-    # Fiber-friendly HTTP adapter built on HTTPX.
-    #
-    # NOTE: This adapter intentionally does NOT implement `#call_stream`.
-    # Streaming consumers will still work via the SDK's full-body SSE parsing
-    # fallback path (see SimpleInference::Client#handle_stream_response).
-    class HTTPX
-      def initialize(timeout: nil)
-        @timeout = timeout
-      end
-
-      def call(request)
-        method = request.fetch(:method).to_s.downcase.to_sym
-        url = request.fetch(:url)
-        headers = request[:headers] || {}
-        body = request[:body]
-
-        client = ::HTTPX
-
-        # Mirror the SDK's timeout semantics:
-        # - `:timeout` is the overall request deadline (maps to HTTPX `request_timeout`)
-        # - `:open_timeout` and `:read_timeout` override connect/read deadlines
-        timeout = request[:timeout] || @timeout
-        open_timeout = request[:open_timeout] || timeout
-        read_timeout = request[:read_timeout] || timeout
-
-        timeout_opts = {}
-        timeout_opts[:request_timeout] = timeout.to_f if timeout
-        timeout_opts[:connect_timeout] = open_timeout.to_f if open_timeout
-        timeout_opts[:read_timeout] = read_timeout.to_f if read_timeout
-
-        unless timeout_opts.empty?
-          client = client.with(timeout: timeout_opts)
-        end
-
-        response = client.request(method, url, headers: headers, body: body)
-
-        # HTTPX may return an error response object instead of raising.
-        if response.respond_to?(:status) && response.status.to_i == 0
-          err = response.respond_to?(:error) ? response.error : nil
-          raise Errors::ConnectionError, (err ? err.message : "HTTPX request failed")
-        end
-
-        response_headers =
-          response.headers.to_h.each_with_object({}) do |(k, v), out|
-            out[k.to_s] = v.is_a?(Array) ? v.join(", ") : v.to_s
-          end
-
-        {
-          status: response.status.to_i,
-          headers: response_headers,
-          body: response.body.to_s,
-        }
-      rescue ::HTTPX::TimeoutError => e
-        raise Errors::TimeoutError, e.message
-      rescue ::HTTPX::Error, IOError, SystemCallError => e
-        raise Errors::ConnectionError, e.message
-      end
-    end
-  end
-end