active_harness 0.3.7 → 0.3.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54990f7712275af0727b75a7518f30f2ecf5ea798fb14548b5872997a6b272bc
-  data.tar.gz: d81370f86507d5c1d42bc12aac01209afb76bed63d2bb5545bb686ef85cb49ad
+  metadata.gz: 5c6df0d88c07312b2546e83f5e69c58d5b3628e4ff31b0885e10a72d032a5a5e
+  data.tar.gz: f2427084db1992f1c0cdcd44c7fe6518cfaa0d348f1d3720ce9fcf78e40783c2
 SHA512:
-  metadata.gz: cc8f9d543c65fde9818611d68073b2a7de6285f37c815d81e6730c393103add7aed45ba9c9eaf7e9461ddbcf5062b3bd2e4978b3b690cbb190b0cf8eeff19209
-  data.tar.gz: 73f6e6c7a606e4f36bebf8cdd330534d4a37fd028f5f53fd2133c8a365caa136e62e5044baa54518b9ff8883022a6c4e4af4a01f84ea0d4bb4798c0d9b584d01
+  metadata.gz: 39575f2575e8dd5d1dc90a512f1d550512d90b57d37d182c10055901c5f15f6bb4a7d425c5a362acacf0be248c237707d0e1362d71d912b2eb449340c20a9ef9
+  data.tar.gz: 41f8adbbb47d9a0e2a17505f470b8a77ffac7f275eb530ee87f3a5f60c3eaa707a6f2610f16f63fc1a73872d75cb02cfad81a0251dd831b685d02fce0f5bad85

data/lib/active_harness/http/client.rb

@@ -4,35 +4,82 @@ module ActiveHarness
   module Http
     # Thin Net::HTTP wrapper — no external dependencies.
     class Client
-      # @param url     [URI]
+      METHODS = {
+        get:    Net::HTTP::Get,
+        post:   Net::HTTP::Post,
+        put:    Net::HTTP::Put,
+        patch:  Net::HTTP::Patch,
+        delete: Net::HTTP::Delete
+      }.freeze
+
+      # @param method  [Symbol]   :get, :post, :put, :patch or :delete
+      # @param url     [URI]      https (default) or http — TLS follows the URL scheme
       # @param headers [Hash{String => String}]
-      # @param body    [String]   JSON-serialized body
+      # @param body    [String, nil] request body (usually JSON-serialized); omit for GET/DELETE
       # @param timeout [Integer]  seconds (open + read)
       # @return        [String]   raw response body; also responds to #http_status
       #                           (Integer) so providers can classify errors by
       #                           status without changing the return type
+      def request(method, url, headers: {}, body: nil, timeout: 30)
+        klass = METHODS[method.to_sym] or raise ArgumentError, "Unsupported HTTP method: #{method.inspect}"
+
+        begin
+          res = build_http(url, timeout).request(build_request(klass, url, headers, body))
+        rescue Net::OpenTimeout, Net::ReadTimeout
+          raise Errors::TimeoutError, "Request to #{url.host} timed out"
+        rescue => e
+          raise Errors::ProviderUnavailableError, "#{url.host} unreachable: #{e.message}"
+        end
+
+        with_http_status(res)
+      end
+
       def post(url, headers:, body:, timeout: 30)
+        request(:post, url, headers: headers, body: body, timeout: timeout)
+      end
+
+      def get(url, headers: {}, timeout: 30)
+        request(:get, url, headers: headers, timeout: timeout)
+      end
+
+      def put(url, headers:, body:, timeout: 30)
+        request(:put, url, headers: headers, body: body, timeout: timeout)
+      end
+
+      def patch(url, headers:, body:, timeout: 30)
+        request(:patch, url, headers: headers, body: body, timeout: timeout)
+      end
+
+      def delete(url, headers: {}, timeout: 30)
+        request(:delete, url, headers: headers, timeout: timeout)
+      end
+
+      private
+
+      def build_http(url, timeout)
         http              = Net::HTTP.new(url.host, url.port)
-        http.use_ssl      = true
+        http.use_ssl      = url.scheme == "https"
         http.open_timeout = timeout
         http.read_timeout = timeout
+        http
+      end
 
-        req = Net::HTTP::Post.new(url)
+      def build_request(klass, url, headers, body)
+        req = klass.new(url)
         headers.each { |k, v| req[k] = v }
-        req.body = body
+        req.body = body if body
+        req
+      end
 
-        res  = http.request(req)
+      # Returns the response body with an #http_status accessor attached.
+      def with_http_status(res)
         body = res.body
         return body if body.nil?
 
-        body = body.dup
+        body   = body.dup
         status = res.code.to_i
         body.define_singleton_method(:http_status) { status }
         body
-      rescue Net::OpenTimeout, Net::ReadTimeout
-        raise Errors::TimeoutError, "Request to #{url.host} timed out"
-      rescue => e
-        raise Errors::ProviderUnavailableError, "#{url.host} unreachable: #{e.message}"
       end
     end
   end

data/lib/active_harness/http/streaming_client.rb

@@ -18,7 +18,7 @@ module ActiveHarness
       # @return [Hash]  { content: String, usage: Hash|nil }
       def post(url, headers:, body:, timeout: 60, on_token:, parse_chunk: nil)
         http              = Net::HTTP.new(url.host, url.port)
-        http.use_ssl      = true
+        http.use_ssl      = url.scheme == "https"
         http.open_timeout = timeout
         http.read_timeout = timeout
 
@@ -31,6 +31,10 @@ module ActiveHarness
         usage   = {}
 
         http.request(req) do |response|
+          # Non-2xx: the body is a plain JSON error, not SSE — read it whole and
+          # raise instead of silently returning an empty stream.
+          raise_for_status!(response.code.to_i, response.read_body) unless response.is_a?(Net::HTTPSuccess)
+
           response.read_body do |chunk|
             buffer += chunk
             while (line_end = buffer.index("\n"))
@@ -55,12 +59,40 @@ module ActiveHarness
         { content: content, usage: usage.empty? ? nil : usage }
       rescue Net::OpenTimeout, Net::ReadTimeout
         raise Errors::TimeoutError, "Request to #{url.host} timed out"
+      rescue Errors::ProviderError
+        raise
       rescue => e
         raise Errors::ProviderUnavailableError, "#{url.host} unreachable: #{e.message}"
       end
 
       private
 
+      # Maps an HTTP error status + body to the same error classes the
+      # non-streaming providers raise. The message is pulled from the common
+      # error shapes ({error:{message}}, {message}, {detail}), else the raw body.
+      def raise_for_status!(status, body)
+        msg  = error_message(body)
+        code = status.to_s
+
+        case status
+        when 401, 403 then raise Errors::InvalidApiKeyError.new(msg,       error_code: code)
+        when 429      then raise Errors::RateLimitError.new(msg,           error_code: code)
+        when 503      then raise Errors::ProviderUnavailableError.new(msg, error_code: code)
+        when 500..599 then raise Errors::ServerError.new(msg,              error_code: code)
+        else               raise Errors::InvalidRequestError.new(msg,      error_code: code)
+        end
+      end
+
+      def error_message(body)
+        data = JSON.parse(body.to_s)
+        msg  = data.dig("error", "message") if data["error"].is_a?(Hash)
+        msg ||= data["error"] if data["error"].is_a?(String)
+        msg ||= data["message"] || data["detail"]
+        (msg.is_a?(String) ? msg : data.to_json)
+      rescue JSON::ParserError, NoMethodError, TypeError
+        body.to_s.strip.empty? ? "HTTP error with empty body" : body.to_s.strip[0, 500]
+      end
+
       def default_chunk(parsed)
         token = parsed.dig("choices", 0, "delta", "content")
         raw_u = parsed["usage"]

data/lib/active_harness.rb

@@ -41,7 +41,7 @@ require_relative "active_harness/pipeline"
 require_relative "active_harness/railtie" if defined?(Rails::Railtie)
 
 module ActiveHarness
-  VERSION = "0.3.7"
+  VERSION = "0.3.8"
 
   class << self
     # Configure ActiveHarness.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_harness
 version: !ruby/object:Gem::Version
-  version: 0.3.7
+  version: 0.3.8
 platform: ruby
 authors:
 - the-teacher