nylas 6.2.3 → 6.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cb37db614a1d3567334d0d7217d50e81a94a3d31bc758c916fa752953fc7369e
-  data.tar.gz: 123be60d4794edb9ea702ae62c2768d39fda98afa7b53157d3e7b53def4b3b98
+  metadata.gz: 537c2669d5e30d03ad70d6acbd18c782865038fcff32779ffca36ece16234900
+  data.tar.gz: bf78777657d01f6907505b473d5304419d95a8f8984455604fe59c86e5a1279b
 SHA512:
-  metadata.gz: 4d26327e107d0a911397a30a8f2f2d2fc7836dcf8d9c4f9448b4ec8ab58aa2cd37595fa7cdcea8c5ade7643d6d9ec8b33451dbf297237501ce0834494946f331
-  data.tar.gz: 9340849392790c37b9c86334a97afe8b5b991c6d681313dee3158f26371953d698114bd38796e02f28c49e6de028594bfee4adae9b9e11d62d7e29cf10ccdb22
+  metadata.gz: bb7bca82b3c7dbb97b8365a4ef5882d86f41256952e17f854e03e1eff92d16a8cee53f57a971a8bc70209d26a7f5721915a6d458b8582adc24aaf9a055257469
+  data.tar.gz: 52196420bcaeb94ea0b31c2a513b57dee5a8dd7eed2f5689564cba0d84e2b63b91751a0616881e0813b63a02a29cd16a1064d78f0a57b6e1e6c4ce31fa0e395f

data/lib/nylas/client.rb

@@ -8,6 +8,8 @@ require_relative "resources/auth"
 require_relative "resources/webhooks"
 require_relative "resources/applications"
 require_relative "resources/folders"
+require_relative "resources/lists"
+require_relative "resources/notetakers"
 require_relative "resources/scheduler"
 
 module Nylas
@@ -98,6 +100,13 @@ module Nylas
       Grants.new(self)
     end
 
+    # The list resources for your Nylas application.
+    #
+    # @return [Nylas::Lists] List resources for your Nylas application
+    def lists
+      Lists.new(self)
+    end
+
     # The message resources for your Nylas application.
     #
     # @return [Nylas::Messages] Message resources for your Nylas application
@@ -112,6 +121,34 @@ module Nylas
       Threads.new(self)
     end
 
+    # The policy resources for your Nylas application.
+    #
+    # @return [Nylas::Policies] Policy resources for your Nylas application.
+    def policies
+      Policies.new(self)
+    end
+
+    # The rule resources for your Nylas application.
+    #
+    # @return [Nylas::Rules] Rule resources for your Nylas application.
+    def rules
+      Rules.new(self)
+    end
+
+    # The workspace resources for your Nylas application.
+    #
+    # @return [Nylas::Workspaces] Workspace resources for your Nylas application.
+    def workspaces
+      Workspaces.new(self)
+    end
+
+    # The domain resources for your Nylas application.
+    #
+    # @return [Nylas::Domains] Domain resources for your Nylas application.
+    def domains
+      Domains.new(self)
+    end
+
     # The webhook resources for your Nylas application.
     #
     # @return [Nylas::Webhooks] Webhook resources for your Nylas application.
@@ -124,5 +161,11 @@ module Nylas
     def scheduler
       Scheduler.new(self)
     end
+
+    # The Notetaker resources for your Nylas application.
+    # @return [Nylas::Notetakers] Notetaker resources for your Nylas application.
+    def notetakers
+      Notetakers.new(self)
+    end
   end
 end

data/lib/nylas/errors.rb

@@ -14,7 +14,7 @@ module Nylas
 
   # Error class representing a failed response from the Nylas API.
   class NylasApiError < AbstractNylasApiError
-    attr_accessor :type, :request_id, :provider_error, :status_code
+    attr_accessor :type, :request_id, :provider_error, :status_code, :headers
 
     # Initializes an error and assigns the given attributes to it.
     #
@@ -23,24 +23,26 @@ module Nylas
     # @param status_code [Integer] Error status code.
     # @param provider_error [Hash, nil] The error from the provider.
     # @param request_id [Hash, nil] The ID of the request.
-    def initialize(type, message, status_code, provider_error = nil, request_id = nil)
+    def initialize(type, message, status_code, provider_error = nil, request_id = nil, headers = nil)
       super(message)
       self.type = type
       self.status_code = status_code
       self.provider_error = provider_error
       self.request_id = request_id
+      self.headers = headers
     end
 
     # Parses the error response.
     #
     # @param response [Hash] Response from the Nylas API.
     # @param status_code [Integer] Error status code.
-    def self.parse_error_response(response, status_code)
+    def self.parse_error_response(response, status_code, headers = nil)
       new(
         response["type"],
         response["message"],
         status_code,
-        response["provider_error"]
+        response["provider_error"],
+        headers
       )
     end
   end

data/lib/nylas/handler/api_operations.rb

@@ -15,22 +15,25 @@ module Nylas
       #
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
-      # @return [Array([Hash, Array], String)] Nylas data object and API Request ID.
-      def get(path:, query_params: {})
-        response = get_raw(path: path, query_params: query_params)
+      # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
+      # @return [Array([Hash, Array], String, Hash)] Nylas data object, API Request ID, and response headers.
+      def get(path:, query_params: {}, headers: {})
+        response = get_raw(path: path, query_params: query_params, headers: headers)
 
-        [response[:data], response[:request_id]]
+        [response[:data], response[:request_id], response[:headers]]
       end
 
       # Performs a GET call to the Nylas API for a list response.
       #
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
-      # @return [Array(Array(Hash), String, String)] Nylas data array, API Request ID, and next cursor.
-      def get_list(path:, query_params: {})
-        response = get_raw(path: path, query_params: query_params)
+      # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
+      # @return [Array<Array<Hash>, String, String, Hash>]
+      #   Nylas data array, API Request ID, next cursor, and response headers.response headers.
+      def get_list(path:, query_params: {}, headers: {})
+        response = get_raw(path: path, query_params: query_params, headers: headers)
 
-        [response[:data], response[:request_id], response[:next_cursor]]
+        [response[:data], response[:request_id], response[:next_cursor], response[:headers]]
       end
 
       private
@@ -39,16 +42,20 @@ module Nylas
       #
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
+      # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
       # @return [Hash] The JSON response from the Nylas API.
-      def get_raw(path:, query_params: {})
-        execute(
+      def get_raw(path:, query_params: {}, headers: {})
+        request = {
           method: :get,
           path: path,
           query: query_params,
           payload: nil,
           api_key: api_key,
           timeout: timeout
-        )
+        }
+        request[:headers] = headers unless headers.empty?
+
+        execute(**request)
       end
     end
 
@@ -62,20 +69,23 @@ module Nylas
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
       # @param request_body [Hash, nil] Request body to pass to the call.
+      #   Defaults to {} when nil to ensure Content-Type: application/json is sent.
       # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
-      # @return Nylas data object and API Request ID.
-      def post(path:, query_params: {}, request_body: nil, headers: {})
-        response = execute(
+      # @return [Array(Hash, String, Hash)] Nylas data object, API Request ID, and response headers.
+      def post(path:, query_params: {}, request_body: nil, headers: {}, serialized_json_body: nil)
+        request = {
           method: :post,
           path: path,
           query: query_params,
-          payload: request_body,
+          payload: request_body || {},
           headers: headers,
           api_key: api_key,
           timeout: timeout
-        )
+        }
+        request[:serialized_json_body] = serialized_json_body unless serialized_json_body.nil?
+        response = execute(**request)
 
-        [response[:data], response[:request_id]]
+        [response[:data], response[:request_id], response[:headers]]
       end
     end
 
@@ -89,18 +99,21 @@ module Nylas
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
       # @param request_body [Hash, nil] Request body to pass to the call.
+      #   Defaults to {} when nil to ensure Content-Type: application/json is sent.
       # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
       # @return Nylas data object and API Request ID.
-      def put(path:, query_params: {}, request_body: nil, headers: {})
-        response = execute(
+      def put(path:, query_params: {}, request_body: nil, headers: {}, serialized_json_body: nil)
+        request = {
           method: :put,
           path: path,
           query: query_params,
-          payload: request_body,
+          payload: request_body || {},
           headers: headers,
           api_key: api_key,
           timeout: timeout
-        )
+        }
+        request[:serialized_json_body] = serialized_json_body unless serialized_json_body.nil?
+        response = execute(**request)
 
         [response[:data], response[:request_id]]
       end
@@ -116,18 +129,21 @@ module Nylas
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
       # @param request_body [Hash, nil] Request body to pass to the call.
+      #   Defaults to {} when nil to ensure Content-Type: application/json is sent.
       # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
       # @return Nylas data object and API Request ID.
-      def patch(path:, query_params: {}, request_body: nil, headers: {})
-        response = execute(
+      def patch(path:, query_params: {}, request_body: nil, headers: {}, serialized_json_body: nil)
+        request = {
           method: :patch,
           path: path,
           query: query_params,
-          payload: request_body,
+          payload: request_body || {},
           headers: headers,
           api_key: api_key,
           timeout: timeout
-        )
+        }
+        request[:serialized_json_body] = serialized_json_body unless serialized_json_body.nil?
+        response = execute(**request)
 
         [response[:data], response[:request_id]]
       end
@@ -142,15 +158,17 @@ module Nylas
       #
       # @param path [String] Destination path for the call.
       # @param query_params [Hash, {}] Query params to pass to the call.
+      # @param request_body [Hash, nil] Optional request body (e.g. cancellation_reason for bookings).
+      #   Defaults to {} to ensure Content-Type: application/json is sent.
       # @param headers [Hash, {}] Additional HTTP headers to include in the payload.
       # @return Nylas data object and API Request ID.
-      def delete(path:, query_params: {}, headers: {})
+      def delete(path:, query_params: {}, request_body: nil, headers: {})
         response = execute(
           method: :delete,
           path: path,
           query: query_params,
           headers: headers,
-          payload: nil,
+          payload: request_body || {},
           api_key: api_key,
           timeout: timeout
         )

data/lib/nylas/handler/http_client.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
-require "rest-client"
+require "httparty"
+require "net/http"
+require "net/http/post/multipart"
 
 require_relative "../errors"
 require_relative "../version"
@@ -28,21 +30,28 @@ module Nylas
     # @param query [Hash, {}] Hash of names and values to include in the query section of the URI
     # fragment.
     # @param payload [Hash, nil] Body to send with the request.
+    # @param serialized_json_body [String, nil] Pre-serialized JSON body to send as-is.
     # @param api_key [Hash, nil] API key to send with the request.
     # @return [Object] Parsed JSON response from the API.
-    def execute(method:, path:, timeout:, headers: {}, query: {}, payload: nil, api_key: nil)
+    def execute(method:, path:, timeout:, headers: {}, query: {}, payload: nil, api_key: nil,
+                serialized_json_body: nil)
       request = build_request(method: method, path: path, headers: headers,
-                              query: query, payload: payload, api_key: api_key, timeout: timeout)
+                              query: query, payload: payload, api_key: api_key, timeout: timeout,
+                              serialized_json_body: serialized_json_body)
       begin
-        rest_client_execute(**request) do |response, _request, result|
+        httparty_execute(**request) do |response, _request, result|
           content_type = nil
-          if response.headers && response.headers[:content_type]
-            content_type = response.headers[:content_type].downcase
+          if response.headers && response.headers["content-type"]
+            content_type = response.headers["content-type"].downcase
           end
 
-          parse_json_evaluate_error(result.code.to_i, response, path, content_type)
+          parsed_response = parse_json_evaluate_error(result.code.to_i, response.body, path, content_type,
+                                                      response.headers)
+          # Include headers in the response
+          parsed_response[:headers] = response.headers unless parsed_response.nil?
+          parsed_response
         end
-      rescue RestClient::Exceptions::OpenTimeout, RestClient::Exceptions::ReadTimeout
+      rescue Net::OpenTimeout, Net::ReadTimeout
         raise Nylas::NylasSdkTimeoutError.new(request[:path], timeout)
       end
     end
@@ -85,20 +94,32 @@ module Nylas
     # @param query [Hash, {}] Hash of names and values to include in the query section of the URI
     # fragment.
     # @param payload [Hash, nil] Body to send with the request.
+    # @param serialized_json_body [String, nil] Pre-serialized JSON body to send as-is.
     # @param timeout [Integer, nil] Timeout value to send with the request.
     # @param api_key [Hash, nil] API key to send with the request.
     # @return [Object] The request information after processing. This includes an updated payload
     # and headers.
     def build_request(
-      method:, path: nil, headers: {}, query: {}, payload: nil, timeout: nil, api_key: nil
+      method:, path: nil, headers: {}, query: {}, payload: nil, timeout: nil, api_key: nil,
+      serialized_json_body: nil
     )
       url = build_url(path, query)
       resulting_headers = default_headers.merge(headers).merge(auth_header(api_key))
-      if !payload.nil? && !payload["multipart"]
+
+      # Check for multipart flag using both string and symbol keys for backwards compatibility
+      is_multipart = !payload.nil? && (payload["multipart"] || payload[:multipart])
+
+      if !serialized_json_body.nil?
+        payload = serialized_json_body
+        resulting_headers["Content-type"] = "application/json"
+      elsif !payload.nil? && !is_multipart
+        normalize_json_encodings!(payload)
         payload = payload&.to_json
         resulting_headers["Content-type"] = "application/json"
-      elsif !payload.nil? && payload["multipart"]
+      elsif is_multipart
+        # Remove multipart flag from both possible key types
         payload.delete("multipart")
+        payload.delete(:multipart)
       end
 
       { method: method, url: url, payload: payload, headers: resulting_headers, timeout: timeout }
@@ -116,23 +137,237 @@ module Nylas
     def parse_response(response)
       return response if response.is_a?(Enumerable)
 
-      Yajl::Parser.new(symbolize_names: true).parse(response)
+      Yajl::Parser.new(symbolize_names: true).parse(response) || raise(Nylas::JsonParseError)
     rescue Yajl::ParseError
       raise Nylas::JsonParseError
     end
 
     private
 
-    # Sends a request to the Nylas REST API.
+    # Sends a request to the Nylas REST API using HTTParty or Net::HTTP for multipart.
+    # Multipart requests use Net::HTTP::Post::Multipart (multipart-post gem) because
+    # HTTParty's multipart handling produces malformed requests that the Nylas API rejects.
     #
     # @param method [Symbol] HTTP method for the API call. Either :get, :post, :delete, or :patch.
     # @param url [String] URL for the API call.
     # @param headers [Hash] HTTP headers to include in the payload.
     # @param payload [String, Hash] Body to send with the request.
     # @param timeout [Hash] Timeout value to send with the request.
-    def rest_client_execute(method:, url:, headers:, payload:, timeout:, &block)
-      ::RestClient::Request.execute(method: method, url: url, payload: payload,
-                                    headers: headers, timeout: timeout, &block)
+    def httparty_execute(method:, url:, headers:, payload:, timeout:)
+      if method == :post && payload.is_a?(Hash) && file_upload?(payload)
+        response = execute_multipart_request(url: url, headers: headers, payload: payload, timeout: timeout)
+      else
+        options = { headers: headers, timeout: timeout }
+        options[:body] = payload if payload
+        response = HTTParty.send(method, url, options)
+      end
+
+      result = create_response_wrapper(response)
+
+      if block_given?
+        yield response, nil, result
+      else
+        response
+      end
+    end
+
+    # Executes multipart POST using Net::HTTP::Post::Multipart (fixes issue #538).
+    # HTTParty's multipart produces malformed requests; multipart-post/UploadIO works correctly.
+    def execute_multipart_request(url:, headers:, payload:, timeout:)
+      uri = URI.parse(url)
+      params = build_multipart_params(payload)
+
+      req = Net::HTTP::Post::Multipart.new(uri.path, params)
+      headers.each { |key, value| req[key] = value }
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == "https")
+      http.read_timeout = timeout
+      http.open_timeout = timeout
+
+      response = http.request(req)
+
+      create_httparty_like_response(response)
+    end
+
+    # Build params hash for Net::HTTP::Post::Multipart with UploadIO for file fields.
+    def build_multipart_params(payload)
+      params = {}
+      payload.each do |key, value|
+        params[key] = if key.is_a?(String) && key != "message" && file_like_value?(value)
+                        value_to_upload_io(value)
+                      else
+                        value.to_s
+                      end
+      end
+      params
+    end
+
+    def file_like_value?(value)
+      return true if value.respond_to?(:read) && (value.is_a?(File) ? !value.closed? : true)
+      if value.is_a?(String) && (value.respond_to?(:original_filename) || value.respond_to?(:content_type))
+        return true
+      end
+
+      false
+    end
+
+    # Convert File, String, or StringIO to UploadIO for multipart-post.
+    def value_to_upload_io(value)
+      content_type = value.respond_to?(:content_type) ? value.content_type : "application/octet-stream"
+      filename = value.respond_to?(:original_filename) ? value.original_filename : "file.bin"
+
+      io = if value.respond_to?(:read) && value.respond_to?(:rewind)
+             value.rewind if value.respond_to?(:rewind)
+             value
+           else
+             require "stringio"
+             content = value.to_s
+             content = content.dup.force_encoding(Encoding::ASCII_8BIT) if content.is_a?(String)
+             StringIO.new(content)
+           end
+
+      UploadIO.new(io, content_type, filename)
+    end
+
+    # Create response object compatible with HTTParty::Response interface.
+    def create_httparty_like_response(net_http_response)
+      headers = net_http_response.to_hash
+      headers = headers.transform_values { |v| v.is_a?(Array) && v.one? ? v.first : v }
+
+      OpenStruct.new(
+        body: net_http_response.body,
+        code: net_http_response.code.to_i,
+        headers: headers
+      )
+    end
+
+    # Create a response wrapper that mimics RestClient::Response.code behavior
+    def create_response_wrapper(response)
+      OpenStruct.new(code: response.code)
+    end
+
+    # Check if payload contains file uploads
+    def file_upload?(payload)
+      return false unless payload.is_a?(Hash)
+
+      # Check for traditional file uploads (File objects or objects that respond to :read)
+      has_file_objects = payload.values.any? do |value|
+        value.respond_to?(:read) || (value.is_a?(File) && !value.closed?)
+      end
+
+      return true if has_file_objects
+
+      # Check if payload was prepared by FileUtils.build_form_request for multipart uploads
+      # This handles binary content attachments that are strings with added singleton methods
+      has_message_field = payload.key?("message") && payload["message"].is_a?(String)
+
+      # Check for attachment fields - these can have custom content_id values (not just "file{N}")
+      # FileUtils.build_form_request creates entries with string values that have singleton methods
+      # like original_filename and content_type defined on them
+      has_attachment_fields = payload.any? do |key, value|
+        next false unless key.is_a?(String) && key != "message"
+
+        # Check if the value is a string with attachment-like singleton methods
+        # (original_filename or content_type), which indicates it's a file content
+        value.is_a?(String) && (value.respond_to?(:original_filename) || value.respond_to?(:content_type))
+      end
+
+      # If we have both a "message" field and attachment fields with file metadata,
+      # this indicates the payload was prepared by FileUtils.build_form_request
+      has_message_field && has_attachment_fields
+    end
+
+    # Prepare multipart payload for HTTParty compatibility
+    # HTTParty requires all multipart fields to have compatible encodings
+    def prepare_multipart_payload(payload)
+      require "stringio"
+
+      modified_payload = payload.dup
+
+      # First, normalize all string encodings to prevent HTTParty encoding conflicts
+      normalize_multipart_encodings!(modified_payload)
+
+      # Handle binary content attachments (file0, file1, etc.) by converting them to enhanced StringIO
+      # HTTParty expects file uploads to be objects with full file-like interface
+      modified_payload.each do |key, value|
+        next unless key.is_a?(String) && key.match?(/^file\d+$/) && value.is_a?(String)
+
+        # Get the original value to check for singleton methods
+        original_value = payload[key]
+
+        # Create an enhanced StringIO object for HTTParty compatibility
+        string_io = create_file_like_stringio(value)
+
+        # Preserve filename and content_type if they exist as singleton methods
+        if original_value.respond_to?(:original_filename)
+          string_io.define_singleton_method(:original_filename) { original_value.original_filename }
+        end
+
+        if original_value.respond_to?(:content_type)
+          string_io.define_singleton_method(:content_type) { original_value.content_type }
+        end
+
+        modified_payload[key] = string_io
+      end
+
+      modified_payload
+    end
+
+    # Normalize string encodings in multipart payload to prevent HTTParty encoding conflicts
+    # This ensures all string fields use consistent ASCII-8BIT encoding for multipart compatibility
+    def normalize_multipart_encodings!(payload)
+      payload.each do |key, value|
+        next unless value.is_a?(String)
+
+        # Force all string values to ASCII-8BIT encoding for multipart compatibility
+        # HTTParty/multipart-post expects binary encoding for consistent concatenation
+        payload[key] = value.dup.force_encoding(Encoding::ASCII_8BIT)
+      end
+    end
+
+    # Normalize JSON encodings for attachment content to ensure binary data is base64 encoded.
+    # This handles cases where users pass raw binary content directly instead of file objects.
+    def normalize_json_encodings!(payload)
+      return unless payload.is_a?(Hash)
+
+      # Handle attachment content encoding for JSON serialization
+      attachments = payload[:attachments] || payload["attachments"]
+      return unless attachments
+
+      attachments.each do |attachment|
+        content = attachment[:content] || attachment["content"]
+        next unless content.is_a?(String)
+
+        # If content appears to be binary (non-UTF-8), base64 encode it
+        next unless content.encoding == Encoding::ASCII_8BIT || !content.valid_encoding?
+
+        encoded_content = Base64.strict_encode64(content)
+        if attachment.key?(:content)
+          attachment[:content] = encoded_content
+        else
+          attachment["content"] = encoded_content
+        end
+      end
+    end
+
+    # Create a StringIO object that behaves more like a File for HTTParty compatibility
+    def create_file_like_stringio(content)
+      # Content is already normalized to ASCII-8BIT by normalize_multipart_encodings!
+      # Create StringIO with the normalized binary content
+      string_io = StringIO.new(content)
+
+      # Add methods that HTTParty/multipart-post might expect
+      string_io.define_singleton_method(:path) { nil }
+      string_io.define_singleton_method(:local_path) { nil }
+      string_io.define_singleton_method(:respond_to_missing?) do |method_name, include_private = false|
+        File.instance_methods.include?(method_name) || super(method_name, include_private)
+      end
+
+      # Set binary mode for file-like behavior
+      string_io.binmode if string_io.respond_to?(:binmode)
+
+      string_io
     end
 
     def setup_http(path, timeout, headers, query, api_key)
@@ -160,50 +395,51 @@ module Nylas
     end
 
     # Parses the response from the Nylas API and evaluates for errors.
-    def parse_json_evaluate_error(http_code, response, path, content_type = nil)
+    def parse_json_evaluate_error(http_code, response, path, content_type = nil, headers = nil)
       begin
         response = parse_response(response) if content_type == "application/json"
       rescue Nylas::JsonParseError
-        handle_failed_response(http_code, response, path)
+        handle_failed_response(http_code, response, path, headers)
         raise
       end
 
-      handle_failed_response(http_code, response, path)
+      handle_failed_response(http_code, response, path, headers)
       response
     end
 
     # Handles failed responses from the Nylas API.
-    def handle_failed_response(http_code, response, path)
+    def handle_failed_response(http_code, response, path, headers = nil)
       return if HTTP_SUCCESS_CODES.include?(http_code)
 
       case response
       when Hash
-        raise error_hash_to_exception(response, http_code, path)
+        raise error_hash_to_exception(response, http_code, path, headers)
       else
         raise NylasApiError.parse_error_response(response, http_code)
       end
     end
 
     # Converts error hashes to exceptions.
-    def error_hash_to_exception(response, status_code, path)
+    def error_hash_to_exception(response, status_code, path, headers = nil)
       return if !response || !response.key?(:error)
 
       if %W[#{api_uri}/v3/connect/token #{api_uri}/v3/connect/revoke].include?(path)
         NylasOAuthError.new(response[:error], response[:error_description], response[:error_uri],
                             response[:error_code], status_code)
       else
-        throw_error(response, status_code)
+        throw_error(response, status_code, headers)
       end
     end
 
-    def throw_error(response, status_code)
+    def throw_error(response, status_code, headers = nil)
       error_obj = response[:error]
 
       # If `error_obj` is just a string, turn it into a hash with default keys.
       if error_obj.is_a?(String)
         error_obj = {
           type: "NylasApiError",
-          message: error_obj
+          message: error_obj,
+          headers: headers
         }
       end
 
@@ -214,7 +450,8 @@ module Nylas
         error_obj[:message],
         status_code,
         provider_error,
-        response[:request_id]
+        response[:request_id],
+        headers
       )
     end
 
@@ -260,6 +497,8 @@ module Nylas
 
     # Set the authorization header for an API query.
     def auth_header(api_key)
+      return {} if api_key.nil?
+
       { "Authorization" => "Bearer #{api_key}" }
     end
   end