simple_inference 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ccaaf770804e4ecb6f308d3e0a864f295ab30e9129a5ec7a8322d9a0dd07c89b
-  data.tar.gz: 67f3526c92ca12c38c01d00b38e8d624655d1ac101b1314475d6a2005dc2badf
+  metadata.gz: 50a8ea07e0e30771b6d42f2bacf12f12b379f1151bb44947bb5febe3cac70cf9
+  data.tar.gz: c655b141ea39e518c5cdcc30cc28bac249ef23acfae8c05f4cf852e199a98a80
 SHA512:
-  metadata.gz: c27972ed32eb27a5923740e5902addae2ac617c124e0e56c41905eb21c119843072e5047487dd2b1e29665e123cb22692da173bd1e48717152f05b5b7c7322e5
-  data.tar.gz: 6219386deb601c540c27a9d309ca2356f6dc4b6604068039da3d9d527ad2a86f3ba882b9095be811dd7e8d3a0910ac9425132f5bf8333c4aa2c8f75f4eda15e5
+  metadata.gz: '0483fda13365abb75bde99643ada2fc95017e4883e07d823d8b86912e9553764befe7c6a92222aeca3ee05d20e8f6b1e1a23a4a74decf45383bc4cc9c055d357'
+  data.tar.gz: 4d115195078c198b2c2c1b4bc1307a05e337884449b19393488374cd1710efaf6186e68c7060417141e5477933ea3fafc5223896adc06c1d1063263437254d56

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?
 
@@ -600,37 +575,12 @@ module SimpleInference
       headers = (response[:headers] || {}).transform_keys { |k| k.to_s.downcase }
       body = response[:body].to_s
 
-      # Decide whether to raise on HTTP errors
-      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)
-        message = "HTTP #{status}"
-
-        begin
-          error_body = JSON.parse(body)
-          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
-        )
-      end
+      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?
@@ -665,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,151 +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]
-        if 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
-
-        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]
-        if 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
-
-        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_adapter → http_adapters}/httpx.rb

@@ -4,17 +4,33 @@ begin
   require "httpx"
 rescue LoadError => e
   raise LoadError,
-        "httpx gem is required for SimpleInference::HTTPAdapter::HTTPX (add `gem \"httpx\"`)",
+        "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 HTTPAdapter
+  module HTTPAdapters
     # Fiber-friendly HTTP adapter built on HTTPX.
-    class 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)
@@ -47,14 +63,12 @@ module SimpleInference
         #
         # NOTE: Some error response objects do not expose the normal response API
         # (e.g. no `#headers`), so we must handle them explicitly.
-        if defined?(::HTTPX::ErrorResponse) && response.is_a?(::HTTPX::ErrorResponse)
-          err = response.respond_to?(:error) ? response.error : nil
-          raise Errors::ConnectionError, (err ? err.message : "HTTPX request failed")
+        if response.is_a?(::HTTPX::ErrorResponse)
+          raise Errors::ConnectionError, (response.error&.message || "HTTPX request failed")
         end
 
-        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")
+        if response.status.to_i == 0
+          raise Errors::ConnectionError, "HTTPX request failed"
         end
 
         response_headers = normalize_headers(response)
@@ -62,7 +76,7 @@ module SimpleInference
         {
           status: response.status.to_i,
           headers: response_headers,
-          body: response.respond_to?(:body) ? response.body.to_s : "",
+          body: response.body.to_s,
         }
       rescue ::HTTPX::TimeoutError => e
         raise Errors::TimeoutError, e.message
@@ -78,8 +92,6 @@ module SimpleInference
         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
@@ -96,20 +108,13 @@ module SimpleInference
         timeout_opts[:connect_timeout] = open_timeout.to_f if open_timeout
         timeout_opts[:read_timeout] = read_timeout.to_f if read_timeout
 
-        unless client.respond_to?(:plugin)
-          return call_stream_via_full_body(
-            method: method,
-            url: url,
-            headers: headers,
-            body: body,
-            timeout: timeout,
-            open_timeout: open_timeout,
-            read_timeout: read_timeout
-          ) { |chunk| yield chunk }
-        end
-
-        client = client.plugin(:stream)
-        client = client.with(timeout: timeout_opts) unless timeout_opts.empty?
+        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 = {}
@@ -118,9 +123,17 @@ module SimpleInference
 
         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.respond_to?(:status) ? stream_response.status.to_i : nil
+            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?
 
@@ -133,11 +146,11 @@ module SimpleInference
         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 if e.respond_to?(:response) && e.response.respond_to?(:status)
-          response_headers = normalize_headers(e.response) if response_headers.empty? && e.respond_to?(:response)
+          status ||= e.response.status.to_i
+          response_headers = normalize_headers(e.response) if response_headers.empty?
         end
 
-        status ||= stream_response.respond_to?(:status) ? stream_response.status.to_i : 0
+        status ||= stream_response.status.to_i
         response_headers = normalize_headers(stream_response) if response_headers.empty?
 
         if streamable_sse?(status, response_headers)
@@ -154,8 +167,6 @@ module SimpleInference
       private
 
       def normalize_headers(response)
-        return {} unless response.respond_to?(: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
@@ -171,33 +182,6 @@ module SimpleInference
 
         content_type.include?("text/event-stream")
       end
-
-      def call_stream_via_full_body(method:, url:, headers:, body:, timeout:, open_timeout:, read_timeout:)
-        response =
-          call(
-            {
-              method: method,
-              url: url,
-              headers: headers,
-              body: body,
-              timeout: timeout,
-              open_timeout: open_timeout,
-              read_timeout: read_timeout,
-            }
-          )
-
-        content_type =
-          (response[:headers] || {}).each_with_object({}) do |(k, v), out|
-            out[k.to_s.downcase] = v
-          end["content-type"].to_s
-
-        if response[:status].to_i >= 200 && response[:status].to_i < 300 && content_type.include?("text/event-stream")
-          yield response[:body].to_s
-          return { status: response[:status].to_i, headers: response[:headers] || {}, body: nil }
-        end
-
-        response
-      end
     end
   end
 end

data/lib/simple_inference/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple_inference
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 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