parse-stack-next 5.5.6 → 5.7.0

data/lib/parse/embeddings/cohere.rb

@@ -68,29 +68,29 @@ module Parse
       class RateLimitError < Error; end
       class TransientError < Error; end
 
-      DEFAULT_BASE_URL    = "https://api.cohere.com/v1"
-      DEFAULT_MODEL       = "embed-english-v3.0"
-      DEFAULT_TIMEOUT     = 30
+      DEFAULT_BASE_URL = "https://api.cohere.com/v1"
+      DEFAULT_MODEL = "embed-english-v3.0"
+      DEFAULT_TIMEOUT = 30
       DEFAULT_OPEN_TIMEOUT = 5
       DEFAULT_MAX_RETRIES = 3
       # Cohere documents a hard cap of 96 inputs per `/embed` call.
-      DEFAULT_BATCH_SIZE  = 96
-      MAX_RESPONSE_BYTES  = 16 * 1024 * 1024
+      DEFAULT_BATCH_SIZE = 96
+      MAX_RESPONSE_BYTES = 16 * 1024 * 1024
 
       MODEL_DEFAULT_DIMENSIONS = {
-        "embed-v4.0"                     => 1536,
-        "embed-english-v3.0"             => 1024,
-        "embed-multilingual-v3.0"        => 1024,
-        "embed-english-light-v3.0"       => 384,
-        "embed-multilingual-light-v3.0"  => 384,
+        "embed-v4.0" => 1536,
+        "embed-english-v3.0" => 1024,
+        "embed-multilingual-v3.0" => 1024,
+        "embed-english-light-v3.0" => 384,
+        "embed-multilingual-light-v3.0" => 384,
       }.freeze
 
       MODEL_MAX_INPUT_TOKENS = {
-        "embed-v4.0"                     => 128_000,
-        "embed-english-v3.0"             => 512,
-        "embed-multilingual-v3.0"        => 512,
-        "embed-english-light-v3.0"       => 512,
-        "embed-multilingual-light-v3.0"  => 512,
+        "embed-v4.0" => 128_000,
+        "embed-english-v3.0" => 512,
+        "embed-multilingual-v3.0" => 512,
+        "embed-english-light-v3.0" => 512,
+        "embed-multilingual-light-v3.0" => 512,
       }.freeze
 
       # Models that accept Cohere's `output_dimension` Matryoshka
@@ -115,10 +115,10 @@ module Parse
       # `:unknown_type` to `"search_document"` would mask cache-key
       # bugs in higher layers (the value participates in cache keys).
       INPUT_TYPE_WIRE_VALUES = {
-        search_query:    "search_query",
+        search_query: "search_query",
         search_document: "search_document",
-        classification:  "classification",
-        clustering:      "clustering",
+        classification: "classification",
+        clustering: "clustering",
       }.freeze
 
       # @param api_key [String] required. Sent as `Authorization: Bearer …`.
@@ -462,7 +462,7 @@ module Parse
             next
           end
           raise BadRequestError,
-                "Parse::Embeddings::Cohere: #{status} from POST #{path.start_with?('/') ? path : "/#{path}"}."
+                "Parse::Embeddings::Cohere: #{status} from POST #{path.start_with?("/") ? path : "/#{path}"}."
         end
       end
 
@@ -498,8 +498,7 @@ module Parse
                 "Parse::Embeddings::Cohere: response body is not a JSON object."
         end
         embeddings = payload["embeddings"]
-        vectors =
-          case embeddings
+        vectors = case embeddings
           when Hash
             f = embeddings["float"]
             unless f.is_a?(Array)
@@ -521,7 +520,7 @@ module Parse
       end
 
       def backoff_seconds(attempt)
-        [0.5 * (2**(attempt - 1)), 30.0].min
+        [0.5 * (2 ** (attempt - 1)), 30.0].min
       end
 
       def retry_after_seconds(response)

data/lib/parse/embeddings/image_fetch.rb

@@ -56,6 +56,7 @@ module Parse
       class InvalidImageType < Parse::Embeddings::Error
         # @return [Symbol] failure-mode tag.
         attr_reader :reason
+
         def initialize(reason, message)
           @reason = reason
           super(message)
@@ -76,6 +77,7 @@ module Parse
           "#<Parse::Embeddings::ImageFetch::FetchedImage mime_type=#{mime_type.inspect} " \
           "bytes=#{bytes.respond_to?(:bytesize) ? bytes.bytesize : 0} url=#{url.inspect}>"
         end
+
         alias_method :to_s, :inspect
       end
 
@@ -88,11 +90,11 @@ module Parse
       # against the sniffed type. Extensions not listed here are ignored
       # (the magic bytes alone govern).
       EXTENSION_MIME = {
-        ".jpg"  => "image/jpeg",
+        ".jpg" => "image/jpeg",
         ".jpeg" => "image/jpeg",
-        ".jpe"  => "image/jpeg",
-        ".png"  => "image/png",
-        ".gif"  => "image/gif",
+        ".jpe" => "image/jpeg",
+        ".png" => "image/png",
+        ".gif" => "image/gif",
         ".webp" => "image/webp",
       }.freeze
 
@@ -109,8 +111,8 @@ module Parse
         return nil unless bytes.is_a?(String) && bytes.bytesize >= 12
         b = bytes.byteslice(0, 16).force_encoding(Encoding::BINARY)
         return "image/jpeg" if b.start_with?("\xFF\xD8\xFF".b)
-        return "image/png"  if b.start_with?("\x89PNG\r\n\x1A\n".b)
-        return "image/gif"  if b.start_with?("GIF87a".b) || b.start_with?("GIF89a".b)
+        return "image/png" if b.start_with?("\x89PNG\r\n\x1A\n".b)
+        return "image/gif" if b.start_with?("GIF87a".b) || b.start_with?("GIF89a".b)
         if b.start_with?("RIFF".b) && b.byteslice(8, 4) == "WEBP".b
           return "image/webp"
         end
@@ -177,26 +179,26 @@ module Parse
       def verify!(bytes, url: nil)
         if bytes.nil? || bytes.empty?
           raise InvalidImageType.new(:empty,
-            "Parse::Embeddings::ImageFetch: downloaded body is empty.")
+                                     "Parse::Embeddings::ImageFetch: downloaded body is empty.")
         end
         mime = sniff_mime(bytes)
         if mime.nil?
           raise InvalidImageType.new(:unknown_magic,
-            "Parse::Embeddings::ImageFetch: leading bytes match no supported image " \
-            "format (JPEG/PNG/GIF/WebP). The Content-Type header is not consulted — " \
-            "unrecognized content is refused outright.")
+                                     "Parse::Embeddings::ImageFetch: leading bytes match no supported image " \
+                                     "format (JPEG/PNG/GIF/WebP). The Content-Type header is not consulted — " \
+                                     "unrecognized content is refused outright.")
         end
         allowed = Parse::Embeddings.allowed_image_types
         unless allowed.include?(mime)
           raise InvalidImageType.new(:type_not_allowed,
-            "Parse::Embeddings::ImageFetch: sniffed type #{mime.inspect} is not in " \
-            "Parse::Embeddings.allowed_image_types (#{allowed.inspect}).")
+                                     "Parse::Embeddings::ImageFetch: sniffed type #{mime.inspect} is not in " \
+                                     "Parse::Embeddings.allowed_image_types (#{allowed.inspect}).")
         end
         ext_mime = extension_mime(url)
         if ext_mime && ext_mime != mime
           raise InvalidImageType.new(:extension_mismatch,
-            "Parse::Embeddings::ImageFetch: URL extension implies #{ext_mime.inspect} " \
-            "but the magic bytes are #{mime.inspect} — refusing MIME-laundered content.")
+                                     "Parse::Embeddings::ImageFetch: URL extension implies #{ext_mime.inspect} " \
+                                     "but the magic bytes are #{mime.inspect} — refusing MIME-laundered content.")
         end
         mime
       end
@@ -210,10 +212,10 @@ module Parse
       def extension_mime(url)
         return nil unless url.is_a?(String)
         path = begin
-          URI.parse(url).path.to_s
-        rescue URI::InvalidURIError
-          return nil
-        end
+            URI.parse(url).path.to_s
+          rescue URI::InvalidURIError
+            return nil
+          end
         dot = path.rindex(".")
         return nil if dot.nil?
         EXTENSION_MIME[path[dot..].to_s.downcase]
@@ -231,10 +233,9 @@ module Parse
       # @param mime [String] sniffed MIME type.
       # @return [String] bytes with metadata removed.
       def strip_metadata(bytes, mime)
-        stripped =
-          case mime
+        stripped = case mime
           when "image/jpeg" then strip_jpeg_app1(bytes)
-          when "image/png"  then strip_png_exif(bytes)
+          when "image/png" then strip_png_exif(bytes)
           when "image/webp" then strip_webp_metadata(bytes)
           else return bytes
           end

data/lib/parse/embeddings/jina.rb

@@ -63,36 +63,36 @@ module Parse
       class RateLimitError < Error; end
       class TransientError < Error; end
 
-      DEFAULT_BASE_URL    = "https://api.jina.ai/v1"
-      DEFAULT_MODEL       = "jina-embeddings-v3"
-      DEFAULT_TIMEOUT     = 30
+      DEFAULT_BASE_URL = "https://api.jina.ai/v1"
+      DEFAULT_MODEL = "jina-embeddings-v3"
+      DEFAULT_TIMEOUT = 30
       DEFAULT_OPEN_TIMEOUT = 5
       DEFAULT_MAX_RETRIES = 3
-      DEFAULT_BATCH_SIZE  = 100
-      MAX_RESPONSE_BYTES  = 16 * 1024 * 1024
+      DEFAULT_BATCH_SIZE = 100
+      MAX_RESPONSE_BYTES = 16 * 1024 * 1024
 
       # Native vector widths. The Matryoshka-capable rows allow the
       # caller to truncate via the `dimensions:` kwarg.
       MODEL_DEFAULT_DIMENSIONS = {
         "jina-embeddings-v5-omni-small" => 1024,
-        "jina-embeddings-v5-omni-nano"  => 512,
+        "jina-embeddings-v5-omni-nano" => 512,
         "jina-embeddings-v5-text-small" => 1024,
-        "jina-embeddings-v5-text-nano"  => 512,
-        "jina-embeddings-v4"            => 2048,
-        "jina-embeddings-v3"            => 1024,
-        "jina-code-embeddings-1.5b"     => 1024,
-        "jina-code-embeddings-0.5b"     => 1024,
+        "jina-embeddings-v5-text-nano" => 512,
+        "jina-embeddings-v4" => 2048,
+        "jina-embeddings-v3" => 1024,
+        "jina-code-embeddings-1.5b" => 1024,
+        "jina-code-embeddings-0.5b" => 1024,
       }.freeze
 
       MODEL_MAX_INPUT_TOKENS = {
         "jina-embeddings-v5-omni-small" => 32_000,
-        "jina-embeddings-v5-omni-nano"  => 32_000,
+        "jina-embeddings-v5-omni-nano" => 32_000,
         "jina-embeddings-v5-text-small" => 32_000,
-        "jina-embeddings-v5-text-nano"  => 32_000,
-        "jina-embeddings-v4"            => 32_000,
-        "jina-embeddings-v3"            => 8_192,
-        "jina-code-embeddings-1.5b"     => 32_000,
-        "jina-code-embeddings-0.5b"     => 32_000,
+        "jina-embeddings-v5-text-nano" => 32_000,
+        "jina-embeddings-v4" => 32_000,
+        "jina-embeddings-v3" => 8_192,
+        "jina-code-embeddings-1.5b" => 32_000,
+        "jina-code-embeddings-0.5b" => 32_000,
       }.freeze
 
       # Models that accept the Matryoshka `dimensions` field. Other
@@ -108,10 +108,10 @@ module Parse
 
       # Map SDK-canonical input_type symbols to Jina `task` strings.
       INPUT_TYPE_WIRE_VALUES = {
-        search_query:    "retrieval.query",
+        search_query: "retrieval.query",
         search_document: "retrieval.passage",
-        classification:  "classification",
-        clustering:      "separation",
+        classification: "classification",
+        clustering: "separation",
       }.freeze
 
       # @param api_key [String] required. Sent as `Authorization: Bearer …`.
@@ -352,7 +352,7 @@ module Parse
       end
 
       def backoff_seconds(attempt)
-        [0.5 * (2**(attempt - 1)), 30.0].min
+        [0.5 * (2 ** (attempt - 1)), 30.0].min
       end
 
       def retry_after_seconds(response)

data/lib/parse/embeddings/local_http.rb

@@ -78,11 +78,11 @@ module Parse
       class RateLimitError < Error; end
       class TransientError < Error; end
 
-      DEFAULT_TIMEOUT      = 30
+      DEFAULT_TIMEOUT = 30
       DEFAULT_OPEN_TIMEOUT = 5
-      DEFAULT_MAX_RETRIES  = 3
-      DEFAULT_BATCH_SIZE   = 32
-      MAX_RESPONSE_BYTES   = 16 * 1024 * 1024
+      DEFAULT_MAX_RETRIES = 3
+      DEFAULT_BATCH_SIZE = 32
+      MAX_RESPONSE_BYTES = 16 * 1024 * 1024
 
       # @param base_url [String] required. Must be http(s):// with a host.
       # @param model [String] required. Identifier the local server expects
@@ -353,7 +353,7 @@ module Parse
       end
 
       def backoff_seconds(attempt)
-        [0.5 * (2**(attempt - 1)), 30.0].min
+        [0.5 * (2 ** (attempt - 1)), 30.0].min
       end
 
       def retry_after_seconds(response)
@@ -414,8 +414,7 @@ module Parse
         # Empty-resolution under allow_private_endpoint is treated as
         # private for the http:// scheme gate below, since the operator
         # has already asserted local-class trust.
-        is_private =
-          if resolved.empty?
+        is_private = if resolved.empty?
             allow_private_endpoint
           else
             resolved.any? { |ip| Parse::File::BLOCKED_CIDRS.any? { |cidr| cidr.include?(ip) } }

data/lib/parse/embeddings/media_file.rb

@@ -0,0 +1,137 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module Parse
+  module Embeddings
+    # A file-backed image or video input that is **streamed** into the
+    # request body rather than read into memory.
+    #
+    # This is the memory-safe counterpart to
+    # {ImageFetch::FetchedImage}, which holds raw bytes. A MediaFile
+    # holds only a path, a sniffed MIME type, and a byte count; the
+    # bytes are read and base64-encoded incrementally by
+    # {StreamingBody} while the request is being written to the socket.
+    # Peak memory stays at {StreamingBody::READ_CHUNK} no matter how
+    # large the file is, which is what makes video viable on a small
+    # dyno.
+    #
+    # Only the first 16 bytes are read at construction time, to sniff
+    # the container. The `Content-Type` header and the filename
+    # extension are never consulted.
+    #
+    # @example stream a local image
+    #   img = Parse::Embeddings::MediaFile.image("diagram.png")
+    #   provider.embed_image([img])
+    #
+    # @example stream a local video
+    #   clip = Parse::Embeddings::MediaFile.video("demo.mp4")
+    #   provider.embed_video([clip])
+    class MediaFile
+      # Voyage documents 20 MB per image and 20 MB per video.
+      # Overridable via {Parse::Embeddings.max_media_bytes=}.
+      DEFAULT_MAX_MEDIA_BYTES = 20 * 1024 * 1024
+
+      # Raised when a file exceeds {Parse::Embeddings.max_media_bytes}.
+      class TooLarge < Parse::Embeddings::Error; end
+
+      # @return [String] absolute path to the backing file.
+      attr_reader :path
+      # @return [String] sniffed MIME type.
+      attr_reader :mime_type
+      # @return [Integer] size in bytes, captured at construction.
+      attr_reader :byte_size
+      # @return [Symbol] `:image` or `:video`.
+      attr_reader :kind
+
+      class << self
+        # Wrap a local image file. Verifies the magic bytes against
+        # {Parse::Embeddings.allowed_image_types}.
+        #
+        # @param path [String]
+        # @return [MediaFile]
+        # @raise [ImageFetch::InvalidImageType]
+        def image(path)
+          header = read_header(path)
+          mime = ImageFetch.sniff_mime(header)
+          if mime.nil?
+            raise ImageFetch::InvalidImageType.new(:unknown_magic,
+                                                   "Parse::Embeddings::MediaFile.image: #{path} matches no supported image " \
+                                                   "format (JPEG/PNG/GIF/WebP).")
+          end
+          allowed = Parse::Embeddings.allowed_image_types
+          unless allowed.include?(mime)
+            raise ImageFetch::InvalidImageType.new(:type_not_allowed,
+                                                   "Parse::Embeddings::MediaFile.image: sniffed type #{mime.inspect} is not in " \
+                                                   "Parse::Embeddings.allowed_image_types (#{allowed.inspect}).")
+          end
+          new(path: path, mime_type: mime, kind: :image)
+        end
+
+        # Wrap a local video file. Verifies the magic bytes against
+        # {Parse::Embeddings.allowed_video_types}.
+        #
+        # @param path [String]
+        # @return [MediaFile]
+        # @raise [VideoSource::InvalidVideoType]
+        def video(path)
+          header = read_header(path)
+          new(path: path, mime_type: VideoSource.verify!(header), kind: :video)
+        end
+
+        private
+
+        # Read only enough bytes to sniff a container. Deliberately
+        # tiny — the whole point of this class is to never hold the
+        # file. A file shorter than this is passed through as-is so the
+        # sniffers can reject it with their own error.
+        def read_header(path)
+          unless ::File.file?(path)
+            raise ArgumentError,
+                  "Parse::Embeddings::MediaFile: #{path.inspect} is not a readable file."
+          end
+          ::File.open(path, "rb") { |f| f.read(16).to_s }
+        end
+      end
+
+      def initialize(path:, mime_type:, kind:)
+        @path = ::File.expand_path(path)
+        @mime_type = mime_type
+        @kind = kind
+        @byte_size = ::File.size(@path)
+        if @byte_size.zero?
+          raise ArgumentError,
+                "Parse::Embeddings::MediaFile: #{path.inspect} is empty."
+        end
+        cap = Parse::Embeddings.max_media_bytes
+        if @byte_size > cap
+          raise TooLarge,
+                "Parse::Embeddings::MediaFile: #{path.inspect} is #{@byte_size} bytes, over " \
+                "the #{cap}-byte limit (Parse::Embeddings.max_media_bytes). Voyage rejects " \
+                "media above 20 MB — downscale or re-encode before embedding."
+        end
+      end
+
+      # The `data:` URI prefix that precedes the streamed base64 in the
+      # wire body. The payload itself is never concatenated here.
+      #
+      # @return [String]
+      def data_uri_prefix
+        "data:#{mime_type};base64,"
+      end
+
+      # Segment descriptor consumed by {StreamingBody}.
+      #
+      # @return [Hash]
+      def stream_segment
+        { path: @path, size: @byte_size }
+      end
+
+      def inspect
+        "#<Parse::Embeddings::MediaFile kind=#{@kind} mime_type=#{@mime_type.inspect} " \
+        "bytes=#{@byte_size} path=#{@path.inspect}>"
+      end
+
+      alias_method :to_s, :inspect
+    end
+  end
+end

data/lib/parse/embeddings/openai.rb

@@ -49,12 +49,12 @@ module Parse
       class RateLimitError < Error; end
       class TransientError < Error; end
 
-      DEFAULT_BASE_URL    = "https://api.openai.com/v1"
-      DEFAULT_MODEL       = "text-embedding-3-small"
-      DEFAULT_TIMEOUT     = 30
+      DEFAULT_BASE_URL = "https://api.openai.com/v1"
+      DEFAULT_MODEL = "text-embedding-3-small"
+      DEFAULT_TIMEOUT = 30
       DEFAULT_OPEN_TIMEOUT = 5
       DEFAULT_MAX_RETRIES = 3
-      DEFAULT_BATCH_SIZE  = 100
+      DEFAULT_BATCH_SIZE = 100
 
       # Hard ceiling on the response body we'll parse. A legitimate
       # OpenAI embeddings response for the worst-case configuration
@@ -397,7 +397,7 @@ module Parse
       # synchronize the retry storm exponentially.
       def backoff_seconds(attempt)
         # 0.5, 1.0, 2.0, 4.0, 8.0 …  capped at 30s
-        [0.5 * (2**(attempt - 1)), 30.0].min
+        [0.5 * (2 ** (attempt - 1)), 30.0].min
       end
 
       def retry_after_seconds(response)

data/lib/parse/embeddings/provider.rb

@@ -24,6 +24,7 @@ module Parse
     # Subclasses MAY override:
     #
     # * {#embed_image}      — v5.1 (multimodal); default `NotImplementedError`
+    # * {#embed_video}      — v5.6 (multimodal); default `NotImplementedError`
     # * {#embed_batch_size} — provider-recommended batch size hint
     # * {#max_input_tokens} — chunker hint
     # * {#normalize?}       — whether output is unit-normalized
@@ -76,6 +77,44 @@ module Parse
         raise NotImplementedError, "#{self.class} does not support image embedding"
       end
 
+      # Embed video sources. Same contract and default posture as
+      # {#embed_image}: providers that do not offer video leave this
+      # raising, and callers discover support through {#modalities}
+      # rather than by rescuing.
+      #
+      # Video payloads are large enough that holding one in memory is a
+      # real operational risk, so the two source forms concrete
+      # providers should accept are:
+      #
+      # * a URL String, forwarded for provider-side fetch after
+      #   {Parse::Embeddings.validate_image_url!} screens it (the SDK
+      #   never downloads the video), and
+      # * a {Parse::Embeddings::MediaFile}, streamed into the request
+      #   body by {Parse::Embeddings::StreamingBody} without ever being
+      #   fully resident.
+      #
+      # Concrete overrides must accept `allow_insecure:` explicitly or
+      # absorb it via `**opts` — see {#embed_image} for why.
+      #
+      # @param sources [Array<String, Parse::Embeddings::MediaFile>]
+      # @param input_type [Symbol] `:search_query` or `:search_document`.
+      # @param allow_insecure [Boolean] forwarded to the URL validator.
+      # @param opts [Hash] provider-specific options.
+      # @return [Array<Array<Float>>] vectors aligned 1:1 with `sources`.
+      # @raise [NotImplementedError] unless the provider offers video.
+      def embed_video(sources, input_type: :search_document, allow_insecure: false, **opts)
+        raise NotImplementedError, "#{self.class} does not support video embedding"
+      end
+
+      # @return [Boolean] whether this provider accepts `modality`.
+      #   Prefer this over rescuing {NotImplementedError} — it answers
+      #   the question without issuing a call.
+      #
+      # @param modality [Symbol] one of `:text`, `:image`, `:video`.
+      def supports_modality?(modality)
+        modalities.include?(modality.to_sym)
+      end
+
       # Batched text embedding. Splits `strings` into chunks of size
       # {#embed_batch_size} (or returns a single-shot call when nil) and
       # concatenates results. Concrete providers should override only
@@ -206,7 +245,7 @@ module Parse
       def inspect_attrs
         out = {}
         out[:model] = safe_call(:model_name)
-        out[:dim]   = safe_call(:dimensions)
+        out[:dim] = safe_call(:dimensions)
         out.compact
       end
 

data/lib/parse/embeddings/qwen.rb

@@ -60,27 +60,27 @@ module Parse
       # Default to the international compatible-mode host. Operators
       # in mainland China should override to
       # `https://dashscope.aliyuncs.com/compatible-mode/v1`.
-      DEFAULT_BASE_URL    = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
-      DEFAULT_MODEL       = "qwen3-embedding-8b"
-      DEFAULT_TIMEOUT     = 30
+      DEFAULT_BASE_URL = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
+      DEFAULT_MODEL = "qwen3-embedding-8b"
+      DEFAULT_TIMEOUT = 30
       DEFAULT_OPEN_TIMEOUT = 5
       DEFAULT_MAX_RETRIES = 3
       # DashScope's compatible endpoint caps embedding requests at 25
       # inputs per call (smaller than OpenAI's 2048). Default below
       # the cap so callers don't have to tune.
-      DEFAULT_BATCH_SIZE  = 10
-      MAX_RESPONSE_BYTES  = 16 * 1024 * 1024
+      DEFAULT_BATCH_SIZE = 10
+      MAX_RESPONSE_BYTES = 16 * 1024 * 1024
 
       MODEL_DEFAULT_DIMENSIONS = {
         "qwen3-embedding-0.6b" => 1024,
-        "qwen3-embedding-4b"   => 2560,
-        "qwen3-embedding-8b"   => 4096,
+        "qwen3-embedding-4b" => 2560,
+        "qwen3-embedding-8b" => 4096,
       }.freeze
 
       MODEL_MAX_INPUT_TOKENS = {
         "qwen3-embedding-0.6b" => 32_000,
-        "qwen3-embedding-4b"   => 32_000,
-        "qwen3-embedding-8b"   => 32_000,
+        "qwen3-embedding-4b" => 32_000,
+        "qwen3-embedding-8b" => 32_000,
       }.freeze
 
       # Every Qwen3-Embedding row is Matryoshka-capable. Kept as an
@@ -329,7 +329,7 @@ module Parse
       end
 
       def backoff_seconds(attempt)
-        [0.5 * (2**(attempt - 1)), 30.0].min
+        [0.5 * (2 ** (attempt - 1)), 30.0].min
       end
 
       def retry_after_seconds(response)

data/lib/parse/embeddings/spend_cap.rb

@@ -118,8 +118,7 @@ module Parse
             end
           end
           mutex.synchronize do
-            limits[key] =
-              if limit_tokens.nil?
+            limits[key] = if limit_tokens.nil?
                 nil
               else
                 cfg = { limit: Integer(limit_tokens), window: w }
@@ -357,7 +356,7 @@ module Parse
         # must not serialize every other tenant's charge).
         def emit_soft_cap_warning(payload)
           return unless defined?(ActiveSupport::Notifications)
-          ActiveSupport::Notifications.instrument(AS_NOTIFICATION_NAME, payload) {}
+          ActiveSupport::Notifications.instrument(AS_NOTIFICATION_NAME, payload) { }
         rescue StandardError
           # A raising subscriber must not turn a successful (admitted)
           # charge into a caller-visible failure.