parse-stack-next 5.3.0 → 5.4.0

data/lib/parse/retrieval/reranker/cohere.rb

@@ -0,0 +1,218 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+require_relative "../reranker"
+
+module Parse
+  module Retrieval
+    module Reranker
+      # Cohere cross-encoder reranker. Wraps `POST /v2/rerank`.
+      #
+      # Cohere's rerank API takes a query plus a list of document strings
+      # and returns a relevance-ordered list of `{ index, relevance_score }`
+      # objects. It is a distinct endpoint from `/v1/embed` /
+      # `/v2/embed` — do NOT confuse it with
+      # {Parse::Embeddings::Cohere} (the embeddings provider).
+      #
+      # The HTTP stack mirrors the embeddings provider's hardening:
+      # explicit `proxy: nil` unless opted in, bounded timeouts, capped
+      # retries with backoff on 429/5xx, response-size cap, and a redacted
+      # `#inspect`.
+      #
+      # @example
+      #   reranker = Parse::Retrieval::Reranker::Cohere.new(
+      #     api_key: ENV.fetch("COHERE_API_KEY"),
+      #     model:   "rerank-v3.5",
+      #   )
+      #   reranker.rerank(query: "rain songs", documents: lyrics, top_n: 5)
+      class Cohere < Base
+        class AuthenticationError < Error; end
+        class RateLimitError < Error; end
+        class TransientError < Error; end
+        class BadRequestError < Error; end
+
+        DEFAULT_BASE_URL = "https://api.cohere.com/v2"
+        DEFAULT_MODEL    = "rerank-v3.5"
+        DEFAULT_TIMEOUT  = 30
+        DEFAULT_OPEN_TIMEOUT = 5
+        DEFAULT_MAX_RETRIES  = 2
+
+        # Cohere documents a cap of 1000 documents per rerank call; the
+        # {Base::MAX_DOCUMENTS} cap (1000) already enforces this.
+        MAX_RESPONSE_BYTES = 5 * 1024 * 1024
+
+        # @param api_key [String] Cohere API key.
+        # @param model [String] rerank model (default {DEFAULT_MODEL}).
+        # @param base_url [String] API base (default {DEFAULT_BASE_URL}).
+        # @param timeout [Integer] read timeout (seconds).
+        # @param open_timeout [Integer] connect timeout (seconds).
+        # @param max_retries [Integer] retry budget for 429 / 5xx /
+        #   transient connection errors.
+        # @param allow_faraday_proxy [Boolean] permit Faraday to honor
+        #   `*_proxy` env vars (default false — explicit `proxy: nil`).
+        def initialize(api_key:, model: DEFAULT_MODEL, base_url: DEFAULT_BASE_URL,
+                       timeout: DEFAULT_TIMEOUT, open_timeout: DEFAULT_OPEN_TIMEOUT,
+                       max_retries: DEFAULT_MAX_RETRIES, allow_faraday_proxy: false)
+          validate_api_key!(api_key)
+          @api_key = api_key
+          @model = model.to_s
+          raise ArgumentError, "Reranker::Cohere: model must be non-empty." if @model.empty?
+          @base_url = base_url.to_s
+          validate_base_url!(@base_url)
+          @timeout = Integer(timeout)
+          @open_timeout = Integer(open_timeout)
+          @max_retries = Integer(max_retries)
+          raise ArgumentError, "Reranker::Cohere: max_retries must be >= 0." if @max_retries.negative?
+          @allow_faraday_proxy = allow_faraday_proxy ? true : false
+          @connection = build_connection
+        end
+
+        # @return [String] the rerank model name.
+        attr_reader :model
+
+        def inspect
+          "#<#{self.class} model=#{@model.inspect} base=#{safe_base_host.inspect} " \
+            "retries=#{@max_retries} api_key=[REDACTED]>"
+        end
+
+        protected
+
+        def rerank_scores(query, documents, top_n)
+          require_faraday!
+          body = {
+            "model"     => @model,
+            "query"     => query,
+            "documents" => documents,
+            "top_n"     => top_n,
+          }
+          payload = post_rerank(body)
+          extract_results!(payload, documents.length)
+        end
+
+        private
+
+        def post_rerank(body)
+          attempts = 0
+          loop do
+            attempts += 1
+            begin
+              response = @connection.post("rerank") { |req| req.body = body.to_json }
+            rescue Faraday::TimeoutError, Faraday::ConnectionFailed => e
+              raise TransientError, "Reranker::Cohere: #{e.class} after #{attempts} attempt(s)." if attempts > @max_retries
+              sleep(backoff_seconds(attempts))
+              next
+            end
+
+            status = response.status
+            return parse_json_body!(response.body) if status >= 200 && status < 300
+
+            case status
+            when 401
+              raise AuthenticationError, "Reranker::Cohere: 401 Unauthorized — check api_key."
+            when 429
+              raise RateLimitError, "Reranker::Cohere: 429 rate limited after #{attempts} attempt(s)." if attempts > @max_retries
+              sleep(retry_after_seconds(response) || backoff_seconds(attempts))
+            when 500..599
+              raise TransientError, "Reranker::Cohere: #{status} after #{attempts} attempt(s)." if attempts > @max_retries
+              sleep(backoff_seconds(attempts))
+            else
+              raise BadRequestError, "Reranker::Cohere: #{status} from POST /rerank."
+            end
+          end
+        end
+
+        # Cohere v2 /rerank response shape:
+        #   { "id": "...", "results": [ { "index": 0, "relevance_score": 0.98 }, ... ],
+        #     "meta": { "billed_units": { "search_units": 1 } } }
+        def extract_results!(payload, doc_count)
+          unless payload.is_a?(Hash)
+            raise InvalidResponseError, "Reranker::Cohere: response body is not a JSON object."
+          end
+          results = payload["results"]
+          unless results.is_a?(Array)
+            raise InvalidResponseError, "Reranker::Cohere: response.results is not an Array."
+          end
+          results.map do |r|
+            unless r.is_a?(Hash)
+              raise InvalidResponseError, "Reranker::Cohere: rerank result is not an object (#{r.inspect})."
+            end
+            Result.new(index: r["index"], relevance_score: r["relevance_score"])
+          end
+        end
+
+        def parse_json_body!(body)
+          s = body.to_s
+          if s.bytesize > MAX_RESPONSE_BYTES
+            raise InvalidResponseError,
+                  "Reranker::Cohere: response body exceeds #{MAX_RESPONSE_BYTES} bytes (#{s.bytesize})."
+          end
+          JSON.parse(s, max_nesting: 32)
+        rescue JSON::ParserError => e
+          raise InvalidResponseError, "Reranker::Cohere: response is not valid JSON (#{e.message})."
+        end
+
+        def build_connection
+          require_faraday!
+          headers = {
+            "Authorization" => "Bearer #{@api_key}",
+            "Content-Type"  => "application/json",
+            "Accept"        => "application/json",
+            "User-Agent"    => "parse-stack-reranker/#{Parse::Stack::VERSION rescue "0"}",
+          }
+          # base_url must end with a trailing slash so Faraday resolves the
+          # relative "rerank" path under /v2/ rather than replacing it.
+          base = @base_url.end_with?("/") ? @base_url : "#{@base_url}/"
+          faraday_opts = { url: base, headers: headers }
+          faraday_opts[:proxy] = nil unless @allow_faraday_proxy
+          conn = Faraday.new(**faraday_opts) do |f|
+            f.options.timeout = @timeout
+            f.options.open_timeout = @open_timeout
+            f.adapter Faraday.default_adapter
+          end
+          conn.proxy = nil if !@allow_faraday_proxy && conn.respond_to?(:proxy=)
+          conn
+        end
+
+        def backoff_seconds(attempt)
+          [0.5 * (2**(attempt - 1)), 30.0].min
+        end
+
+        def retry_after_seconds(response)
+          ra = response.respond_to?(:headers) ? response.headers["retry-after"] || response.headers["Retry-After"] : nil
+          return nil unless ra
+          v = ra.to_f
+          v.positive? ? [v, 60.0].min : nil
+        end
+
+        def validate_api_key!(api_key)
+          unless api_key.is_a?(String) && !api_key.empty?
+            raise ArgumentError, "Reranker::Cohere: api_key must be a non-empty String."
+          end
+        end
+
+        def validate_base_url!(base_url)
+          uri = URI.parse(base_url)
+          unless uri.is_a?(URI::HTTPS) || uri.is_a?(URI::HTTP)
+            raise ArgumentError, "Reranker::Cohere: base_url must be http(s) (got #{base_url.inspect})."
+          end
+        rescue URI::InvalidURIError => e
+          raise ArgumentError, "Reranker::Cohere: invalid base_url #{base_url.inspect} (#{e.message})."
+        end
+
+        def safe_base_host
+          URI.parse(@base_url).host
+        rescue StandardError
+          "?"
+        end
+
+        def require_faraday!
+          require "faraday" unless defined?(Faraday)
+        rescue LoadError
+          raise Error, "Reranker::Cohere requires the `faraday` gem."
+        end
+      end
+    end
+  end
+end

data/lib/parse/retrieval/reranker.rb

@@ -0,0 +1,157 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Parse
+  module Retrieval
+    # Cross-encoder reranking for retrieved documents.
+    #
+    # A reranker takes a query and a list of candidate document texts and
+    # returns a relevance-ordered scoring. It runs AFTER the (vector,
+    # lexical, or hybrid) retrieval step and BEFORE chunking, reordering
+    # the retrieved documents by a more expensive cross-encoder relevance
+    # model than the first-stage similarity score.
+    #
+    # == Protocol
+    #
+    # A reranker is any object that responds to:
+    #
+    #   #rerank(query:, documents:, top_n: nil) -> Array<Result>
+    #
+    # where `documents` is an Array<String> and the return is an Array of
+    # {Result} (`index` into `documents`, plus `relevance_score`),
+    # descending by relevance. Implementations MUST:
+    #
+    # * Return at most `documents.length` results (and at most `top_n`
+    #   when given).
+    # * Use 0-based `index` values that are valid positions in the input.
+    # * Never raise for an empty `documents` list — return `[]`.
+    #
+    # {Base} provides input validation and result normalization so
+    # adapters only implement the network call ({Base#rerank_scores}).
+    #
+    # @example wiring into retrieve
+    #   reranker = Parse::Retrieval::Reranker::Cohere.new(api_key: ENV.fetch("COHERE_API_KEY"))
+    #   chunks = Parse::Retrieval.retrieve(query: q, klass: Article, k: 30,
+    #                                      rerank: reranker, rerank_top_n: 5)
+    module Reranker
+      # The Cohere `/v2/rerank` adapter is loaded lazily — it requires
+      # Faraday, which the core retrieval path does not.
+      autoload :Cohere, ::File.expand_path("reranker/cohere", __dir__)
+
+      # Base error for the reranker layer. Adapters raise subclasses.
+      class Error < StandardError; end
+
+      # Raised when a reranker returns a response that doesn't satisfy the
+      # protocol (bad index, non-numeric score, over-length result set).
+      class InvalidResponseError < Error; end
+
+      # A single rerank result: the 0-based position of a document in the
+      # input list, plus its cross-encoder relevance score (higher is more
+      # relevant; range is provider-defined).
+      Result = Struct.new(:index, :relevance_score, keyword_init: true)
+
+      # Common superclass: validates inputs, bounds `top_n`, and
+      # normalizes raw `(index, score)` pairs into sorted {Result}s.
+      # Concrete adapters implement {#rerank_scores}.
+      class Base
+        # Hard cap on the number of documents a single rerank call may
+        # carry, to bound provider cost / payload size. Providers
+        # typically cap around 1000; we stay conservative.
+        MAX_DOCUMENTS = 1000
+
+        # Rerank `documents` against `query`.
+        #
+        # @param query [String] the natural-language query.
+        # @param documents [Array<String>] candidate document texts.
+        # @param top_n [Integer, nil] return at most this many results.
+        # @return [Array<Result>] descending by `relevance_score`.
+        def rerank(query:, documents:, top_n: nil)
+          unless query.is_a?(String) && !query.strip.empty?
+            raise ArgumentError, "#{self.class}#rerank: query must be a non-empty String."
+          end
+          docs = Array(documents).map(&:to_s)
+          return [] if docs.empty?
+          if docs.length > MAX_DOCUMENTS
+            raise ArgumentError,
+                  "#{self.class}#rerank: #{docs.length} documents exceeds MAX_DOCUMENTS=#{MAX_DOCUMENTS}."
+          end
+          n = top_n.nil? ? docs.length : [Integer(top_n), docs.length].min
+          n = docs.length if n <= 0
+
+          pairs = rerank_scores(query, docs, n)
+          normalize_results(pairs, docs.length, n)
+        end
+
+        protected
+
+        # Adapter hook: return an Array of `[index, score]` pairs (or
+        # {Result}s) for `documents`. `top_n` is a hint; the base class
+        # re-bounds and re-sorts regardless.
+        #
+        # @param query [String]
+        # @param documents [Array<String>]
+        # @param top_n [Integer]
+        # @return [Array<Array(Integer, Numeric)>, Array<Result>]
+        def rerank_scores(query, documents, top_n)
+          raise NotImplementedError, "#{self.class}#rerank_scores must be implemented."
+        end
+
+        private
+
+        def normalize_results(pairs, doc_count, top_n)
+          results = Array(pairs).map do |p|
+            idx, score =
+              case p
+              when Result then [p.index, p.relevance_score]
+              when Array  then [p[0], p[1]]
+              when Hash   then [p[:index] || p["index"], p[:relevance_score] || p["relevance_score"]]
+              else
+                raise InvalidResponseError, "#{self.class}: unexpected rerank result element #{p.inspect}."
+              end
+            i = Integer(idx)
+            unless i >= 0 && i < doc_count
+              raise InvalidResponseError,
+                    "#{self.class}: rerank index #{i} out of range 0...#{doc_count}."
+            end
+            unless score.is_a?(Numeric) && score.to_f.finite?
+              raise InvalidResponseError,
+                    "#{self.class}: rerank relevance_score #{score.inspect} is not a finite number."
+            end
+            Result.new(index: i, relevance_score: score.to_f)
+          end
+          # Defensive: drop duplicate indices (keep the first / highest),
+          # then sort descending and bound to top_n.
+          seen = {}
+          results.each { |r| seen[r.index] ||= r }
+          seen.values.sort_by { |r| [-r.relevance_score, r.index] }.first(top_n)
+        end
+      end
+
+      # Deterministic, zero-network reranker for tests and offline use.
+      # Scores each document by lexical token overlap with the query
+      # (Jaccard-ish: shared unique lowercased word count, tie-broken by
+      # input order). No external dependency, fully reproducible.
+      class Fixture < Base
+        protected
+
+        def rerank_scores(query, documents, _top_n)
+          q_tokens = tokenize(query)
+          documents.each_with_index.map do |doc, i|
+            d_tokens = tokenize(doc)
+            overlap = (q_tokens & d_tokens).length
+            # Normalize into a 0..1-ish score so output looks like a real
+            # relevance score; longer-overlap docs rank higher.
+            denom = [q_tokens.length, 1].max
+            [i, overlap.to_f / denom]
+          end
+        end
+
+        private
+
+        def tokenize(text)
+          text.to_s.downcase.scan(/[a-z0-9]+/).uniq
+        end
+      end
+    end
+  end
+end

data/lib/parse/retrieval/retriever.rb

@@ -3,6 +3,7 @@
 
 require_relative "chunker"
 require_relative "chunk"
+require_relative "reranker"
 
 module Parse
   # Retrieval-augmented-generation (RAG) helpers. `Parse::RAG` is a
@@ -98,25 +99,33 @@ module Parse
     #   propagates and aborts the whole call (fail-closed). Kept as an
     #   injection point so this model-layer method stays free of any
     #   agent-layer dependency.
-    # @param hybrid [Object, nil] reserved — raises {NotImplementedError}
-    #   if truthy. Hybrid (vector + lexical) retrieval lands in a later
-    #   release; the kwarg locks the API shape now.
-    # @param rerank [Object, nil] reserved — raises {NotImplementedError}
-    #   if non-nil. Cross-encoder rerank lands in a later release.
+    # @param hybrid [Boolean, Hash, nil] when truthy, fuse a lexical
+    #   Atlas Search branch with the `$vectorSearch` branch via
+    #   reciprocal-rank fusion (see {Parse::Core::VectorSearchable#hybrid_search}).
+    #   `true` uses defaults (lexical query = `query`); a Hash may carry
+    #   `:lexical`, `:vector`, and `:fusion` sub-configs.
+    # @param rerank [#rerank, nil] a {Parse::Retrieval::Reranker::Base}
+    #   (or any object answering `#rerank(query:, documents:, top_n:)`).
+    #   When present, retrieved documents are reordered by the
+    #   cross-encoder relevance score BEFORE chunking, and the chunk score
+    #   becomes the rerank relevance score.
+    # @param rerank_top_n [Integer, nil] keep only the top-N documents
+    #   after reranking (defaults to all retrieved documents).
     # @param scope_opts [Hash] ACL/CLP scope kwargs forwarded verbatim to
-    #   `find_similar`: `session_token:` / `acl_user:` / `acl_role:` /
-    #   `master:`.
+    #   `find_similar` / `hybrid_search`: `session_token:` / `acl_user:` /
+    #   `acl_role:` / `master:`.
     # @return [Array<Parse::Retrieval::Chunk>] descending by score; chunk
     #   order within a document is positional.
     def retrieve(query:, klass: nil, field: nil, text_field: nil, k: 10,
                  filter: nil, vector_filter: nil, chunker: nil,
                  tenant_scope: nil, score_quantize: false,
                  source_transform: nil, hybrid: nil, rerank: nil,
-                 **scope_opts)
-      raise NotImplementedError,
-            "Parse::Retrieval.retrieve: `hybrid:` is reserved for a future release." if hybrid
-      raise NotImplementedError,
-            "Parse::Retrieval.retrieve: `rerank:` is reserved for a future release." if rerank
+                 rerank_top_n: nil, **scope_opts)
+      if rerank && !rerank.respond_to?(:rerank)
+        raise ArgumentError,
+              "Parse::Retrieval.retrieve: `rerank:` must respond to #rerank " \
+              "(a Parse::Retrieval::Reranker::Base); got #{rerank.class}."
+      end
 
       # `class:` alias (reserved word — arrives via **scope_opts).
       klass ||= scope_opts.delete(:class)
@@ -129,25 +138,60 @@ module Parse
       resolved_text_field = (text_field || infer_text_field!(klass)).to_sym
       merged_vector_filter = fold_tenant_scope(klass, vector_filter, tenant_scope)
       chunker ||= default_chunker
+      text_wire = wire_name(klass, resolved_text_field)
 
-      raw_hits = klass.find_similar(
-        text: query,
-        k: k,
-        field: field,
-        filter: filter,
-        vector_filter: merged_vector_filter,
-        raw: true,
-        **scope_opts,
-      )
+      raw_hits =
+        if hybrid
+          fetch_hybrid_hits(klass, query, k, field, filter, merged_vector_filter,
+                            tenant_scope, hybrid, scope_opts)
+        else
+          klass.find_similar(
+            text: query, k: k, field: field, filter: filter,
+            vector_filter: merged_vector_filter, raw: true, **scope_opts,
+          )
+        end
       return [] if raw_hits.nil? || raw_hits.empty?
 
-      text_wire = wire_name(klass, resolved_text_field)
+      raw_hits = apply_rerank(rerank, query, raw_hits, text_wire, rerank_top_n) if rerank
 
       raw_hits.flat_map do |doc|
         build_chunks_for(doc, klass, text_wire, score_quantize, source_transform, chunker)
       end
     end
 
+    # @!visibility private
+    # Run the hybrid (lexical + vector) branch and return fused raw rows.
+    # Tenant scope is folded into BOTH branches: the vector branch via the
+    # Atlas pre-filter (`merged_vector_filter`) and the lexical branch via
+    # a post-`$search` `$match` (so neither branch leaks cross-tenant
+    # document existence).
+    def fetch_hybrid_hits(klass, query, k, field, filter, merged_vector_filter,
+                          tenant_scope, hybrid, scope_opts)
+      cfg = hybrid.is_a?(Hash) ? hybrid : {}
+      lexical = (cfg[:lexical] || cfg["lexical"] || {}).dup
+      vector  = (cfg[:vector]  || cfg["vector"]  || {}).dup
+      fusion  = cfg[:fusion] || cfg["fusion"]
+
+      lexical[:query] ||= query
+      # Tenant scope must be AUTHORITATIVE in BOTH branches. The previous
+      # `||=` form let a caller-supplied `vector[:vector_filter]` (or a
+      # colliding `lexical[:filter]`) REPLACE the tenant-folded filter
+      # rather than narrow within it — silently dropping tenant isolation
+      # and contradicting this method's "folded into BOTH branches"
+      # contract. `merge_filters` is last-wins, so ordering the tenant
+      # constraint LAST guarantees its key survives any caller collision:
+      # callers can narrow the result set but never escape their tenant.
+      lexical[:filter] = merge_filters(filter, lexical[:filter], tenant_filter_hash(klass, tenant_scope))
+      vector[:field] ||= field unless field.nil?
+      vector[:filter] = merge_filters(vector[:filter], filter)
+      vector[:vector_filter] = merge_filters(vector[:vector_filter], merged_vector_filter)
+
+      klass.hybrid_search(
+        text: query, lexical: lexical, vector: vector,
+        k: k, fusion: fusion, raw: true, **scope_opts,
+      )
+    end
+
     # @!visibility private
     def resolve_class!(klass)
       resolved =
@@ -227,10 +271,53 @@ module Parse
       doc[sym]
     end
 
+    # @!visibility private
+    # Reorder retrieved documents by a cross-encoder reranker and stamp
+    # each surviving hit with its `_rerank_score`. The reranker scores the
+    # document's presentation text (the same `text_field` used for
+    # chunking). Index alignment between `documents` and `raw_hits` is
+    # preserved so the returned `index` maps back to the right hit.
+    def apply_rerank(reranker, query, raw_hits, text_wire, top_n)
+      documents = raw_hits.map { |doc| fetch_field(doc, text_wire, text_wire).to_s }
+      results = reranker.rerank(query: query, documents: documents, top_n: top_n)
+      results.map do |r|
+        hit = raw_hits[r.index]
+        next nil if hit.nil?
+        hit = hit.dup
+        hit["_rerank_score"] = r.relevance_score
+        hit
+      end.compact
+    end
+
+    # @!visibility private
+    # Convert a `{ field:, value: }` tenant scope into a `{ wire => value }`
+    # filter hash (the lexical branch's post-`$search` `$match`), or nil.
+    def tenant_filter_hash(klass, tenant_scope)
+      return nil if tenant_scope.nil?
+      field = tenant_scope[:field] || tenant_scope["field"]
+      return nil if field.nil?
+      value = tenant_scope.key?(:value) ? tenant_scope[:value] : tenant_scope["value"]
+      { wire_name(klass, field) => value }
+    end
+
+    # @!visibility private
+    # Shallow-merge non-empty filter hashes (left-to-right; later keys
+    # win). Returns nil when nothing is left to apply.
+    def merge_filters(*filters)
+      merged = {}
+      filters.each do |f|
+        next if f.nil? || (f.respond_to?(:empty?) && f.empty?)
+        merged.merge!(f)
+      end
+      merged.empty? ? nil : merged
+    end
+
     # @!visibility private
     def build_chunks_for(doc, klass, text_wire, score_quantize, source_transform, chunker)
       object_id = (doc["_id"] || doc[:_id] || doc["objectId"] || doc[:objectId]).to_s
-      raw_score = doc["_vscore"] || doc[:_vscore]
+      raw_score = doc["_rerank_score"] || doc[:_rerank_score] ||
+                  doc["_hybrid_score"] || doc[:_hybrid_score] ||
+                  doc["_vscore"] || doc[:_vscore]
       score = quantize_score(raw_score, score_quantize)
 
       text = fetch_field(doc, text_wire, text_wire)

data/lib/parse/stack/version.rb

@@ -6,6 +6,6 @@ module Parse
   # The Parse Server SDK for Ruby
   module Stack
     # The current version.
-    VERSION = "5.3.0"
+    VERSION = "5.4.0"
   end
 end

data/lib/parse/stack.rb

@@ -940,6 +940,23 @@ module Parse
       end
       Parse.client.send_analytics(event_name, dimensions, **opts)
     end
+
+    # Capability probe against the connected Parse Server, delegated to the
+    # default client. Builds on the memoized `serverInfo` fetch — see
+    # {Parse::API::Server#server_supports?} for the capability table and the
+    # fail-open-to-modern semantics.
+    # @param feature [Symbol] a capability key.
+    # @return [Boolean] whether the connected server supports the feature.
+    def server_supports?(feature)
+      Parse.client.server_supports?(feature)
+    end
+
+    # The coarse `features` block advertised by `GET /serverInfo`, delegated
+    # to the default client. @see Parse::API::Server#server_features
+    # @return [Hash] the advertised features block, or `{}` if unavailable.
+    def server_features
+      Parse.client.server_features
+    end
   end
 
   # Error raised when {Parse::CreateLock#synchronize} cannot acquire the