simple_inference 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 324b5bd8986fee7b2130229b1bb7ad277b1c476c71ed07c5a350845f91ae23a5
-  data.tar.gz: b746716fe0e9364bf1085acc4ac2a09dfe6ca5703831562869a96fdf43ea29a2
+  metadata.gz: ccaaf770804e4ecb6f308d3e0a864f295ab30e9129a5ec7a8322d9a0dd07c89b
+  data.tar.gz: 67f3526c92ca12c38c01d00b38e8d624655d1ac101b1314475d6a2005dc2badf
 SHA512:
-  metadata.gz: 25baf84b1d22f57ed1ccb4b0413acf79cad258efee5e2a31b33d6a0247a87b175492cf293a67c6c7c2503c7d3c28e32283e21dba1aeb1bcbbe621203975e7972
-  data.tar.gz: ba78fc2c974118d4046119cc378202556e3d50611514df0cb4a9affa41412c5bb1a77aeccaef34071de15792a63b17bb5f484cafec8f506f7372660ba09fc5fa
+  metadata.gz: c27972ed32eb27a5923740e5902addae2ac617c124e0e56c41905eb21c119843072e5047487dd2b1e29665e123cb22692da173bd1e48717152f05b5b7c7322e5
+  data.tar.gz: 6219386deb601c540c27a9d309ca2356f6dc4b6604068039da3d9d527ad2a86f3ba882b9095be811dd7e8d3a0910ac9425132f5bf8333c4aa2c8f75f4eda15e5

data/lib/simple_inference/client.rb

@@ -426,6 +426,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,26 +482,115 @@ 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
+
+      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
+
+      [MultipartStream.new(parts), headers]
+    end
+
+    class MultipartStream
+      def initialize(parts)
+        @parts = parts
+        @part_index = 0
+        @string_offset = 0
+        @size = nil
+      end
+
+      def read(length = nil, outbuf = nil)
+        return "".b if length.nil? && eof?
+        return nil if eof?
+
+        out = outbuf ? outbuf.replace("".b) : +"".b
+
+        if length.nil?
+          while (chunk = read(16_384))
+            out << chunk
+          end
+          return out
+        end
+
+        while out.bytesize < length && !eof?
+          part = @parts.fetch(@part_index)
+
+          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
+
+        return nil if out.empty? && eof?
+
+        out
       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"
+      def size
+        @size ||= compute_size
+      end
+
+      private
 
-      while (chunk = io.read(16_384))
-        body << chunk
+      def eof?
+        @part_index >= @parts.length
       end
 
-      body << "\r\n--#{boundary}--\r\n"
+      def advance_part!
+        @part_index += 1
+        @string_offset = 0
+      end
 
-      [body, headers]
+      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
+
+        total
+      end
     end
 
     def handle_response(request_env, expect_json:, raise_on_http_error:)
@@ -523,7 +613,13 @@ module SimpleInference
 
         begin
           error_body = JSON.parse(body)
-          message = error_body["error"] || error_body["message"] || message
+          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

data/lib/simple_inference/http_adapter/httpx.rb

@@ -11,13 +11,10 @@ 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)
+      def initialize(timeout: nil, client: ::HTTPX)
         @timeout = timeout
+        @client = client
       end
 
       def call(request)
@@ -26,7 +23,7 @@ module SimpleInference
         headers = request[:headers] || {}
         body = request[:body]
 
-        client = ::HTTPX
+        client = @client
 
         # Mirror the SDK's timeout semantics:
         # - `:timeout` is the overall request deadline (maps to HTTPX `request_timeout`)
@@ -47,26 +44,160 @@ module SimpleInference
         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 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")
+        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")
         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
+        response_headers = normalize_headers(response)
 
         {
           status: response.status.to_i,
           headers: response_headers,
-          body: response.body.to_s,
+          body: response.respond_to?(: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]
+
+        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
+
+        # 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
+
+        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?
+
+        streaming = nil
+        response_headers = {}
+        status = nil
+        full_body = +"".b
+
+        stream_response = client.request(method, url, headers: headers, body: body, stream: true)
+
+        begin
+          stream_response.each do |chunk|
+            status ||= stream_response.respond_to?(:status) ? stream_response.status.to_i : nil
+            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 if e.respond_to?(:response) && e.response.respond_to?(:status)
+          response_headers = normalize_headers(e.response) if response_headers.empty? && e.respond_to?(:response)
+        end
+
+        status ||= stream_response.respond_to?(:status) ? stream_response.status.to_i : 0
+        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)
+        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
+      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
+
+      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/http_adapter.rb

@@ -34,7 +34,21 @@ module SimpleInference
         end
 
         body = request[:body]
-        req.body = body if 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)
 
@@ -75,7 +89,21 @@ module SimpleInference
         end
 
         body = request[:body]
-        req.body = body if 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 = {}

data/lib/simple_inference/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleInference
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 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.1
 platform: ruby
 authors:
 - jasl