boxcars 0.8.4 → 0.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40c67f759e97f22570fba131b967c73b871b1f96cfbc97df78b1c0438bdf4291
-  data.tar.gz: 55f5e64fa79b8035e1bceb95912cbc5a8c587c29fa3b09d89a65ab83fe4375a6
+  metadata.gz: c1970a509d4c6eebaeaa06792993f7aaa1ba8d2d030e878138a8d6f821726fcc
+  data.tar.gz: 66ae9f13950ab9a0dd2369a1450fd14d4426faa95d8a62da7b4c7deeddbc6b3d
 SHA512:
-  metadata.gz: ba4b4434d263c9b4a875f5ab2db607d11a91795592f39c608143c058a38b773e6349ece90946f7a2137a6edd56d375ebd5992195921660ceac2fa5b4262e6ef5
-  data.tar.gz: c8d58cdfeb28d9a2d6bcba655478d7dd3572db4c2fbd72a566cca6a71c37941d0b7592c02c75f3430e8e7821dcf959942de2d960335864d70da1976e9f7ae63a
+  metadata.gz: 7e6d1f2f4788bb24de873a2e7270b52f44ce31017ccd39e1db321b91bd595d1f832c6c9aa4b9ca587626c3390928e70025014a360ba8052b9e870c50566ccb29
+  data.tar.gz: 4073745656e6944e8e686eee4502916038470ff32261990c1444e50d951a819288a24b993dc51659168b9246dab7020f40fd20f210b9421ab5890e6ec4402d66

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    boxcars (0.8.4)
+    boxcars (0.8.5)
       faraday-retry (~> 2.0)
       google_search_results (~> 2.2)
       gpt4all (~> 0.0.5)
@@ -47,7 +47,7 @@ GEM
       protocol-http1 (~> 0.19.0)
       protocol-http2 (~> 0.16.0)
       traces (>= 0.10.0)
-    async-http-faraday (0.21.0)
+    async-http-faraday (0.22.0)
       async-http (~> 0.42)
       faraday
     async-io (1.43.2)
@@ -67,7 +67,7 @@ GEM
       bigdecimal
       rexml
     date (3.4.1)
-    debug (1.10.0)
+    debug (1.11.0)
       irb (~> 1.10)
       reline (>= 0.3.8)
     diff-lcs (1.6.2)
@@ -83,11 +83,11 @@ GEM
       logger
     faraday-http-cache (2.5.1)
       faraday (>= 0.8)
-    faraday-multipart (1.1.0)
+    faraday-multipart (1.1.1)
       multipart-post (~> 2.0)
-    faraday-net_http (3.4.0)
+    faraday-net_http (3.4.1)
       net-http (>= 0.5.0)
-    faraday-retry (2.3.1)
+    faraday-retry (2.3.2)
       faraday (~> 2.0)
     fiber-annotation (0.2.0)
     fiber-local (1.1.0)
@@ -114,8 +114,8 @@ GEM
       domain_name (~> 0.5)
     i18n (1.14.7)
       concurrent-ruby (~> 1.0)
-    intelligence (0.8.0)
-      dynamicschema (~> 1.0.0.beta03)
+    intelligence (1.0.0)
+      dynamicschema (~> 1.0)
       faraday (~> 2.7)
       json-repair (~> 0.2)
       mime-types (~> 3.6)
@@ -132,7 +132,7 @@ GEM
     mime-types (3.7.0)
       logger
       mime-types-data (~> 3.2025, >= 3.2025.0507)
-    mime-types-data (3.2025.0603)
+    mime-types-data (3.2025.0624)
     minitest (5.25.5)
     multi_json (1.15.0)
     multipart-post (2.4.1)
@@ -186,7 +186,7 @@ GEM
     racc (1.8.1)
     rainbow (3.1.1)
     rake (13.3.0)
-    rdoc (6.14.0)
+    rdoc (6.14.1)
       erb
       psych (>= 4.0.0)
     regexp_parser (2.10.0)
@@ -202,7 +202,7 @@ GEM
       rspec-core (~> 3.13.0)
       rspec-expectations (~> 3.13.0)
       rspec-mocks (~> 3.13.0)
-    rspec-core (3.13.4)
+    rspec-core (3.13.5)
       rspec-support (~> 3.13.0)
     rspec-expectations (3.13.5)
       diff-lcs (>= 1.2.0, < 2.0)
@@ -211,7 +211,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.13.0)
     rspec-support (3.13.4)
-    rubocop (1.76.1)
+    rubocop (1.77.0)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
@@ -219,7 +219,7 @@ GEM
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 2.9.3, < 3.0)
-      rubocop-ast (>= 1.45.0, < 2.0)
+      rubocop-ast (>= 1.45.1, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 4.0)
     rubocop-ast (1.45.1)
@@ -243,14 +243,14 @@ GEM
       addressable (>= 2.3.5)
       faraday (>= 0.17.3, < 3)
     securerandom (0.4.1)
-    sqlite3 (2.7.0-aarch64-linux-gnu)
-    sqlite3 (2.7.0-aarch64-linux-musl)
-    sqlite3 (2.7.0-arm-linux-gnu)
-    sqlite3 (2.7.0-arm-linux-musl)
-    sqlite3 (2.7.0-arm64-darwin)
-    sqlite3 (2.7.0-x86_64-darwin)
-    sqlite3 (2.7.0-x86_64-linux-gnu)
-    sqlite3 (2.7.0-x86_64-linux-musl)
+    sqlite3 (2.7.1-aarch64-linux-gnu)
+    sqlite3 (2.7.1-aarch64-linux-musl)
+    sqlite3 (2.7.1-arm-linux-gnu)
+    sqlite3 (2.7.1-arm-linux-musl)
+    sqlite3 (2.7.1-arm64-darwin)
+    sqlite3 (2.7.1-x86_64-darwin)
+    sqlite3 (2.7.1-x86_64-linux-gnu)
+    sqlite3 (2.7.1-x86_64-linux-musl)
     stringio (3.1.7)
     strings-ansi (0.2.0)
     timeout (0.4.3)

data/lib/boxcars/engine/openai.rb

@@ -1,246 +1,256 @@
 # frozen_string_literal: true
 
-require 'openai'
-require 'json'
-require 'securerandom'
+require "openai"
+require "json"
+require "securerandom"
 
 module Boxcars
-  # A engine that uses OpenAI's API.
+  # Engine that talks to OpenAI’s REST API.
   class Openai < Engine
     include UnifiedObservability
-    attr_reader :prompts, :open_ai_params, :model_kwargs, :batch_size
+
+    CHAT_MODEL_REGEX = /(^gpt-4)|(-turbo\b)|(^o\d)|(gpt-3\.5-turbo)/
+    O_SERIES_REGEX   = /^o/
 
     DEFAULT_PARAMS = {
       model: "gpt-4o-mini",
       temperature: 0.1,
       max_tokens: 4096
     }.freeze
-    DEFAULT_NAME = "OpenAI engine"
-    DEFAULT_DESCRIPTION = "useful for when you need to use AI to answer questions. " \
-                          "You should ask targeted questions"
-
-    def initialize(name: DEFAULT_NAME, description: DEFAULT_DESCRIPTION, prompts: [], batch_size: 20, **kwargs)
-      user_id = kwargs.delete(:user_id)
-      @open_ai_params = DEFAULT_PARAMS.merge(kwargs)
-      # Special handling for o1-mini model (deprecated?)
-      if @open_ai_params[:model] =~ /^o/ && @open_ai_params[:max_tokens]
-        @open_ai_params[:max_completion_tokens] = @open_ai_params.delete(:max_tokens)
-        @open_ai_params.delete(:temperature) # o1-mini might not support temperature
-      end
 
-      @prompts = prompts
-      @batch_size = batch_size
+    DEFAULT_NAME        = "OpenAI engine"
+    DEFAULT_DESCRIPTION = "Useful when you need AI to answer questions. Ask targeted questions."
+
+    attr_reader :prompts, :open_ai_params, :batch_size
+
+    # --------------------------------------------------------------------------
+    #  Construction
+    # --------------------------------------------------------------------------
+    def initialize(name: DEFAULT_NAME,
+                   description: DEFAULT_DESCRIPTION,
+                   prompts: [],
+                   batch_size: 20,
+                   **kwargs)
+      user_id          = kwargs.delete(:user_id)
+      @open_ai_params  = adjust_for_o_series!(DEFAULT_PARAMS.merge(kwargs))
+      @prompts         = prompts
+      @batch_size      = batch_size
       super(description:, name:, user_id:)
     end
 
-    def self.open_ai_client(openai_access_token: nil)
-      access_token = Boxcars.configuration.openai_access_token(openai_access_token:)
-      organization_id = Boxcars.configuration.organization_id
-      # log_errors is good for the gem's own logging
-      ::OpenAI::Client.new(access_token:, organization_id:, log_errors: true)
-    end
+    # --------------------------------------------------------------------------
+    #  Public API
+    # --------------------------------------------------------------------------
+    def client(prompt:, inputs: {}, openai_access_token: nil, **kwargs)
+      start_time       = Time.now
+      response_data    = { response_obj: nil, parsed_json: nil,
+                           success: false, error: nil, status_code: nil }
+      current_params   = open_ai_params.merge(kwargs)
+      is_chat_model    = chat_model?(current_params[:model])
+      prompt_object    = prompt.is_a?(Array) ? prompt.first : prompt
+      api_request      = build_api_request(prompt_object, inputs, current_params, chat: is_chat_model)
 
-    def conversation_model?(model_name)
-      !!(model_name =~ /(^gpt-4)|(-turbo\b)|(^o\d)|(gpt-3\.5-turbo)/) # Added gpt-3.5-turbo
+      begin
+        raw_response = execute_api_call(
+          self.class.open_ai_client(openai_access_token:),
+          is_chat_model,
+          api_request
+        )
+        process_response(raw_response, response_data)
+      rescue ::OpenAI::Error, StandardError => e
+        handle_error(e, response_data)
+      ensure
+        track_openai_observability(
+          {
+            start_time:,
+            prompt_object: prompt_object,
+            inputs: inputs,
+            api_request: api_request,
+            current_params: current_params,
+            is_chat_model: is_chat_model
+          },
+          response_data
+        )
+      end
+
+      handle_call_outcome(response_data:)
     end
 
-    def _prepare_openai_chat_request(prompt_object, inputs, current_params)
-      get_params(prompt_object, inputs, current_params.dup)
+    # Convenience one-shot helper used by Engine#generate
+    def run(question, **)
+      prompt      = Prompt.new(template: question)
+      raw_json    = client(prompt:, inputs: {}, **)
+      extract_answer_from_choices(raw_json["choices"]).tap do |ans|
+        Boxcars.debug("Answer: #{ans}", :cyan)
+      end
     end
 
-    def _prepare_openai_completion_request(prompt_object, inputs, current_params)
-      prompt_text_for_api = prompt_object.as_prompt(inputs:)
-      prompt_text_for_api = prompt_text_for_api[:prompt] if prompt_text_for_api.is_a?(Hash) && prompt_text_for_api.key?(:prompt)
-      { prompt: prompt_text_for_api }.merge(current_params).tap { |p| p.delete(:messages) }
+    # Expose the defaults so callers can introspect or dup/merge them
+    def default_params = open_ai_params
+
+    # --------------------------------------------------------------------------
+    #  Class helpers
+    # --------------------------------------------------------------------------
+    def self.open_ai_client(openai_access_token: nil)
+      ::OpenAI::Client.new(
+        access_token: Boxcars.configuration.openai_access_token(openai_access_token:),
+        organization_id: Boxcars.configuration.organization_id,
+        log_errors: true
+      )
     end
 
-    def _execute_openai_api_call(client, is_chat_model, api_request_params)
-      if is_chat_model
-        log_messages_debug(api_request_params[:messages]) if Boxcars.configuration.log_prompts && api_request_params[:messages]
-        client.chat(parameters: api_request_params)
-      else
-        Boxcars.debug("Prompt after formatting:\n#{api_request_params[:prompt]}", :cyan) if Boxcars.configuration.log_prompts
-        client.completions(parameters: api_request_params)
+    # -- Public helper -------------------------------------------------------------
+    # Some callers outside this class still invoke `check_response` directly.
+    # It simply raises if the JSON body contains an "error" payload.
+    def check_response(response) # rubocop:disable Naming/PredicateMethod
+      if (msg = openai_error_message(response))
+        raise Boxcars::Error, msg
       end
+
+      true
     end
 
-    def _process_openai_response(raw_response, response_data)
-      response_data[:response_obj] = raw_response
-      response_data[:parsed_json] = raw_response # Already parsed by OpenAI gem
+    private
 
-      if raw_response && !raw_response["error"]
-        response_data[:success] = true
-        response_data[:status_code] = 200 # Inferred
+    # -- Request construction ---------------------------------------------------
+    def build_api_request(prompt_object, inputs, params, chat:)
+      if chat
+        build_chat_params(prompt_object, inputs, params.dup)
       else
-        response_data[:success] = false
-        err_details = raw_response["error"] if raw_response
-        msg = err_details ? "#{err_details['type']}: #{err_details['message']}" : "Unknown OpenAI API Error"
-        response_data[:error] ||= StandardError.new(msg) # Use ||= to not overwrite existing exception
+        build_completion_params(prompt_object, inputs, params.dup)
       end
     end
 
-    def _handle_openai_api_error(error, response_data)
-      response_data[:error] = error
-      response_data[:success] = false
-      response_data[:status_code] = error.http_status if error.respond_to?(:http_status)
+    def build_chat_params(prompt_object, inputs, params)
+      po        = if prompt_object.is_a?(Boxcars::Prompt)
+                    prompt_object
+                  else
+                    Boxcars::Prompt.new(template: prompt_object.to_s)
+                  end
+      formatted = po.as_messages(inputs).merge(params)
+      adjust_for_o_series!(formatted)
     end
 
-    def _handle_openai_standard_error(error, response_data)
-      response_data[:error] = error
-      response_data[:success] = false
+    def build_completion_params(prompt_object, inputs, params)
+      prompt_txt = prompt_object.as_prompt(inputs:)
+      prompt_txt = prompt_txt[:prompt] if prompt_txt.is_a?(Hash) && prompt_txt.key?(:prompt)
+      { prompt: prompt_txt }.merge(params).tap { |h| h.delete(:messages) }
     end
 
-    def client(prompt:, inputs: {}, openai_access_token: nil, **kwargs)
-      start_time = Time.now
-      response_data = { response_obj: nil, parsed_json: nil, success: false, error: nil, status_code: nil }
-      current_params = open_ai_params.merge(kwargs)
-      current_prompt_object = prompt.is_a?(Array) ? prompt.first : prompt
-      api_request_params = nil
-      is_chat_model = conversation_model?(current_params[:model])
-
-      begin
-        clnt = Openai.open_ai_client(openai_access_token:)
-        api_request_params = if is_chat_model
-                               _prepare_openai_chat_request(current_prompt_object, inputs, current_params)
-                             else
-                               _prepare_openai_completion_request(current_prompt_object, inputs, current_params)
-                             end
-        raw_response = _execute_openai_api_call(clnt, is_chat_model, api_request_params)
-        _process_openai_response(raw_response, response_data)
-      rescue ::OpenAI::Error => e
-        _handle_openai_api_error(e, response_data)
-      rescue StandardError => e
-        _handle_openai_standard_error(e, response_data)
-      ensure
-        call_context = {
-          start_time:,
-          prompt_object: current_prompt_object,
-          inputs:,
-          api_request_params:,
-          current_params:,
-          is_chat_model:
-        }
-        _track_openai_observability(call_context, response_data)
+    # -- API call / response ----------------------------------------------------
+    def execute_api_call(client, chat_mode, api_request)
+      if chat_mode
+        log_messages_debug(api_request[:messages]) if Boxcars.configuration.log_prompts
+        client.chat(parameters: api_request)
+      else
+        Boxcars.debug("Prompt after formatting:\n#{api_request[:prompt]}", :cyan) if Boxcars.configuration.log_prompts
+        client.completions(parameters: api_request)
       end
-
-      _openai_handle_call_outcome(response_data:)
     end
 
-    # Called by Engine#generate to check the response from the client.
-    # @param response [Hash] The parsed JSON response from the OpenAI API.
-    # @raise [Boxcars::Error] if the response contains an error.
-    # rubocop:disable Naming/PredicateMethod
-    def check_response(response)
-      if response.is_a?(Hash) && response["error"]
-        err_details = response["error"]
-        msg = err_details ? "#{err_details['type']}: #{err_details['message']}" : "Unknown OpenAI API Error in check_response"
-        raise Boxcars::Error, msg
+    def process_response(raw, data)
+      data[:response_obj] = raw
+      data[:parsed_json]  = raw
+
+      if (msg = openai_error_message(raw))
+        data[:success]     = false
+        data[:status_code] = raw&.dig("error", "code") || 500
+        data[:error]       = StandardError.new(msg)
+      else
+        data[:success]     = true
+        data[:status_code] = 200
       end
-      true
     end
-    # rubocop:enable Naming/PredicateMethod
 
-    def run(question, **)
-      prompt = Prompt.new(template: question)
-      # client now returns the raw JSON response. We need to extract the answer.
-      raw_response = client(prompt:, inputs: {}, **)
-      answer = _extract_openai_answer_from_choices(raw_response["choices"])
-      Boxcars.debug("Answer: #{answer}", :cyan)
-      answer
+    def handle_error(error, data)
+      data[:error]        = error
+      data[:success]      = false
+      data[:status_code]  = error.respond_to?(:http_status) ? error.http_status : 500
     end
 
-    def default_params
-      open_ai_params
+    def handle_call_outcome(response_data:)
+      return response_data[:parsed_json] if response_data[:success]
+
+      if response_data[:error]
+        raise_api_error(response_data[:error])
+      else
+        raise_body_error(response_data[:response_obj])
+      end
     end
 
-    private
+    # -- Extraction helpers -----------------------------------------------------
+    def extract_answer_from_choices(choices)
+      raise Error, "OpenAI: No choices found in response" unless choices.is_a?(Array) && choices.any?
 
-    def log_messages_debug(messages)
-      return unless messages.is_a?(Array)
+      content = choices.map { |c| c.dig("message", "content") }.compact
+      return content.join("\n").strip unless content.empty?
+
+      text = choices.map { |c| c["text"] }.compact
+      return text.join("\n").strip unless text.empty?
 
-      Boxcars.debug(messages.last(2).map { |p| ">>>>>> Role: #{p[:role]} <<<<<<\n#{p[:content]}" }.join("\n"), :cyan)
+      raise Error, "OpenAI: Could not extract answer from choices"
     end
 
-    def get_params(prompt_object, inputs, params)
-      # Ensure prompt_object is a Boxcars::Prompt
-      current_prompt_object = if prompt_object.is_a?(Boxcars::Prompt)
-                                prompt_object
-                              else
-                                Boxcars::Prompt.new(template: prompt_object.to_s)
-                              end
+    # -- Utility helpers --------------------------------------------------------
+    def chat_model?(model_name) = CHAT_MODEL_REGEX.match?(model_name)
 
-      # Use as_messages for chat models
-      formatted_params = current_prompt_object.as_messages(inputs).merge(params)
+    def openai_error_message(json)
+      err = json&.dig("error")
+      return unless err
 
-      # Handle models like o1-mini that don't support the system role
-      if formatted_params[:model] =~ /^o/ && formatted_params[:messages].first&.fetch(:role)&.to_s == 'system'
-        formatted_params[:messages].first[:role] = :user
-      end
-      # o1-mini specific param adjustments (already in initialize, but good to ensure here if params are rebuilt)
-      if formatted_params[:model] =~ /^o/
-        formatted_params.delete(:response_format)
-        formatted_params.delete(:stop)
-        if formatted_params.key?(:max_tokens) && !formatted_params.key?(:max_completion_tokens)
-          formatted_params[:max_completion_tokens] = formatted_params.delete(:max_tokens)
-        end
-        formatted_params.delete(:temperature)
-      end
-      formatted_params
+      err.is_a?(Hash) ? "#{err['type']}: #{err['message']}" : err.to_s
     end
 
-    def _handle_openai_error_outcome(error_data)
-      detailed_error_message = error_data.message
-      if error_data.respond_to?(:json_body) && error_data.json_body
-        detailed_error_message += " - Details: #{error_data.json_body}"
+    def adjust_for_o_series!(params)
+      return params unless params[:model] =~ O_SERIES_REGEX
+
+      params[:messages][0][:role] = :user if params.dig(:messages, 0, :role).to_s == "system"
+      params.delete(:response_format)
+      params.delete(:stop)
+      if params.key?(:max_tokens) && !params.key?(:max_completion_tokens)
+        params[:max_completion_tokens] =
+          params.delete(:max_tokens)
       end
-      Boxcars.error("OpenAI Error: #{detailed_error_message} (#{error_data.class.name})", :red)
-      raise error_data
+      params.delete(:temperature)
+      params
     end
 
-    def _handle_openai_response_body_error(response_obj)
-      err_details = response_obj&.dig("error")
-      msg = err_details ? "#{err_details['type']}: #{err_details['message']}" : "Unknown error from OpenAI API"
-      raise Error, msg
-    end
+    def log_messages_debug(messages)
+      return unless messages.is_a?(Array)
 
-    def _extract_openai_answer_from_choices(choices)
-      raise Error, "OpenAI: No choices found in response" unless choices.is_a?(Array) && !choices.empty?
+      Boxcars.debug(
+        messages.last(2).map { |m| ">>>>>> Role: #{m[:role]} <<<<<<\n#{m[:content]}" }.join("\n"),
+        :cyan
+      )
+    end
 
-      if choices.first&.dig("message", "content")
-        choices.map { |c| c.dig("message", "content") }.join("\n").strip
-      elsif choices.first&.dig("text")
-        choices.map { |c| c["text"] }.join("\n").strip
-      else
-        raise Error, "OpenAI: Could not extract answer from choices"
-      end
+    # -- Error raising ----------------------------------------------------------
+    def raise_api_error(err)
+      msg = err.message
+      msg += " - Details: #{err.json_body}" if err.respond_to?(:json_body) && err.json_body
+      Boxcars.error("OpenAI Error: #{msg} (#{err.class})", :red)
+      raise err
     end
 
-    def _openai_handle_call_outcome(response_data:)
-      if response_data[:error]
-        _handle_openai_error_outcome(response_data[:error])
-      elsif !response_data[:success] # e.g. raw_response["error"] was present
-        _handle_openai_response_body_error(response_data[:response_obj]) # Raises an error
-      else
-        response_data[:parsed_json] # Return the raw parsed JSON for Engine#generate
-      end
+    def raise_body_error(response_obj)
+      raise Error, openai_error_message(response_obj) || "Unknown error from OpenAI API"
     end
 
-    def _track_openai_observability(call_context, response_data)
-      duration_ms = ((Time.now - call_context[:start_time]) * 1000).round
-      is_chat_model = call_context[:is_chat_model]
-      api_request_params = call_context[:api_request_params] || {}
-      request_context = {
-        prompt: call_context[:prompt_object],
-        inputs: call_context[:inputs],
-        user_id:,
-        conversation_for_api: is_chat_model ? api_request_params[:messages] : api_request_params[:prompt]
-      }
+    # -- Observability ----------------------------------------------------------
+    def track_openai_observability(call_ctx, response_data)
+      duration_ms = ((Time.now - call_ctx[:start_time]) * 1000).round
+      api_req     = call_ctx[:api_request] || {}
 
       track_ai_generation(
-        duration_ms:,
-        current_params: call_context[:current_params],
-        request_context:,
-        response_data:,
+        duration_ms: duration_ms,
+        current_params: call_ctx[:current_params],
+        request_context: {
+          prompt: call_ctx[:prompt_object],
+          inputs: call_ctx[:inputs],
+          user_id: user_id,
+          conversation_for_api: call_ctx[:is_chat_model] ? api_req[:messages] : api_req[:prompt]
+        },
+        response_data: response_data,
         provider: :openai
       )
     end

data/lib/boxcars/version.rb

@@ -2,5 +2,5 @@
 
 module Boxcars
   # The current version of the gem.
-  VERSION = "0.8.4"
+  VERSION = "0.8.5"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: boxcars
 version: !ruby/object:Gem::Version
-  version: 0.8.4
+  version: 0.8.5
 platform: ruby
 authors:
 - Francis Sullivan