basecamp-sdk 0.15.0 → 0.17.0

data/lib/basecamp/generated/types.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Auto-generated from OpenAPI spec. Do not edit manually.
-# Generated: 2026-08-12T19:58:36Z
+# Generated: 2026-09-08T23:57:39Z
 
 require "json"
 require "time"
@@ -1135,6 +1135,58 @@ module Basecamp
       end
     end
 
+    # ClientInvitationError
+    class ClientInvitationError
+      include TypeHelpers
+      attr_accessor :email_address, :messages
+
+      # @return [Array<Symbol>]
+      def self.required_fields
+        %i[email_address messages].freeze
+      end
+
+      def initialize(data = {})
+        @email_address = data["email_address"]
+        @messages = data["messages"]
+      end
+
+      def to_h
+        {
+          "email_address" => @email_address,
+          "messages" => @messages,
+        }.reject { |k, v| v.nil? && !["email_address"].include?(k) }
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
+    # ClientInvitationErrors
+    class ClientInvitationErrors
+      include TypeHelpers
+      attr_accessor :errors
+
+      # @return [Array<Symbol>]
+      def self.required_fields
+        %i[errors].freeze
+      end
+
+      def initialize(data = {})
+        @errors = parse_array(data["errors"], "ClientInvitationError")
+      end
+
+      def to_h
+        {
+          "errors" => @errors,
+        }.compact
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
     # ClientReply
     class ClientReply
       include TypeHelpers
@@ -1374,6 +1426,37 @@ module Basecamp
       end
     end
 
+    # CreateClientRequest
+    class CreateClientRequest
+      include TypeHelpers
+      attr_accessor :email_address, :company_name, :name, :title
+
+      # @return [Array<Symbol>]
+      def self.required_fields
+        %i[email_address].freeze
+      end
+
+      def initialize(data = {})
+        @email_address = data["email_address"]
+        @company_name = data["company_name"]
+        @name = data["name"]
+        @title = data["title"]
+      end
+
+      def to_h
+        {
+          "email_address" => @email_address,
+          "company_name" => @company_name,
+          "name" => @name,
+          "title" => @title,
+        }.compact
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
     # CreatePersonRequest
     class CreatePersonRequest
       include TypeHelpers
@@ -3169,7 +3252,7 @@ module Basecamp
       include TypeHelpers
       # @!attribute [rw] clientside
       #   @deprecated This shape is deprecated since 2024-01: Use Client Visibility feature instead
-      attr_accessor :app_url, :created_at, :id, :name, :status, :updated_at, :url, :bookmark_url, :bookmarked, :client_company, :clients_enabled, :clientside, :description, :dock, :end_date, :purpose, :start_date
+      attr_accessor :app_url, :created_at, :id, :name, :status, :updated_at, :url, :bookmark_url, :bookmarked, :client_company, :clients_enabled, :clientside, :description, :dock, :end_date, :purpose, :star_url, :starred, :start_date
 
       # @return [Array<Symbol>]
       def self.required_fields
@@ -3193,6 +3276,8 @@ module Basecamp
         @dock = parse_array(data["dock"], "DockItem")
         @end_date = data["end_date"]
         @purpose = data["purpose"]
+        @star_url = data["star_url"]
+        @starred = parse_boolean(data["starred"])
         @start_date = data["start_date"]
       end
 
@@ -3214,6 +3299,8 @@ module Basecamp
           "dock" => @dock,
           "end_date" => @end_date,
           "purpose" => @purpose,
+          "star_url" => @star_url,
+          "starred" => @starred,
           "start_date" => @start_date,
         }.compact
       end
@@ -3245,6 +3332,31 @@ module Basecamp
       end
     end
 
+    # ProjectClientEnablement
+    class ProjectClientEnablement
+      include TypeHelpers
+      attr_accessor :clients_enabled
+
+      # @return [Array<Symbol>]
+      def self.required_fields
+        %i[clients_enabled].freeze
+      end
+
+      def initialize(data = {})
+        @clients_enabled = parse_boolean(data["clients_enabled"])
+      end
+
+      def to_h
+        {
+          "clients_enabled" => @clients_enabled,
+        }.compact
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
     # ProjectConstruction
     class ProjectConstruction
       include TypeHelpers
@@ -4289,6 +4401,99 @@ module Basecamp
       end
     end
 
+    # TemplateLibrary
+    class TemplateLibrary
+      include TypeHelpers
+      attr_accessor :bucket, :todolists, :todoset
+
+      # @return [Array<Symbol>]
+      def self.required_fields
+        %i[bucket todolists todoset].freeze
+      end
+
+      def initialize(data = {})
+        @bucket = parse_type(data["bucket"], "RecordingBucket")
+        @todolists = parse_array(data["todolists"], "Todolist")
+        @todoset = parse_type(data["todoset"], "RecordingParent")
+      end
+
+      def to_h
+        {
+          "bucket" => @bucket,
+          "todolists" => @todolists,
+          "todoset" => @todoset,
+        }.compact
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
+    # TemplateLibraryConfirmationPerson
+    class TemplateLibraryConfirmationPerson
+      include TypeHelpers
+      attr_accessor :avatar_url, :id, :name
+
+      # @return [Array<Symbol>]
+      def self.required_fields
+        %i[avatar_url id name].freeze
+      end
+
+      def initialize(data = {})
+        @avatar_url = data["avatar_url"]
+        @id = parse_integer(data["id"])
+        @name = data["name"]
+      end
+
+      def to_h
+        {
+          "avatar_url" => @avatar_url,
+          "id" => @id,
+          "name" => @name,
+        }.compact
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
+    # TemplateLibraryCopy
+    class TemplateLibraryCopy
+      include TypeHelpers
+      attr_accessor :destination_parent_id, :id, :source_recording_id, :status, :url, :destination_todolist
+
+      # @return [Array<Symbol>]
+      def self.required_fields
+        %i[destination_parent_id id source_recording_id status url].freeze
+      end
+
+      def initialize(data = {})
+        @destination_parent_id = parse_integer(data["destination_parent_id"])
+        @id = parse_integer(data["id"])
+        @source_recording_id = parse_integer(data["source_recording_id"])
+        @status = data["status"]
+        @url = data["url"]
+        @destination_todolist = parse_type(data["destination_todolist"], "Todolist")
+      end
+
+      def to_h
+        {
+          "destination_parent_id" => @destination_parent_id,
+          "id" => @id,
+          "source_recording_id" => @source_recording_id,
+          "status" => @status,
+          "url" => @url,
+          "destination_todolist" => @destination_todolist,
+        }.compact
+      end
+
+      def to_json(*args)
+        to_h.to_json(*args)
+      end
+    end
+
     # TimelineAttachment
     class TimelineAttachment
       include TypeHelpers

data/lib/basecamp/http.rb

@@ -176,7 +176,11 @@ module Basecamp
     # @param url [String] absolute URL
     # @return [Response]
     def get_download(url)
-      request_with_retry(:get, url, retry_on: DOWNLOAD_RETRY_ON, accept: nil)
+      # download: true projects this flow's hooks and transport errors (SPEC
+      # §9): the caller's URL can smuggle a signed query through the rewrite
+      # into hop 1, and a transport error renders the URL it failed on. The
+      # wire request keeps the query; only the renderings are projected.
+      request_with_retry(:get, url, retry_on: DOWNLOAD_RETRY_ON, accept: nil, download: true)
     end
 
     # Fetches all pages of a paginated resource.
@@ -396,7 +400,7 @@ module Basecamp
     end
 
     def request_with_retry(method, url, params: {}, allow_cross_origin: false, operation: nil, retry_on: nil,
-      accept: "application/json")
+      accept: "application/json", download: false)
       op_retry = operation && Http.operation_retry(operation)
       # The cap is floored at one attempt on every path: whether a request
       # reaches the wire at all must not depend on whether the operation
@@ -422,7 +426,7 @@ module Basecamp
 
         begin
           return single_request(method, url, params: params, body: nil, attempt: attempt,
-            allow_cross_origin: allow_cross_origin, accept: accept, refresh_replay: false)
+            allow_cross_origin: allow_cross_origin, accept: accept, refresh_replay: false, download: download)
         rescue Basecamp::AuthError => e
           # SPEC §4: the refresh replay is a request on the wire, so it spends
           # an attempt from THIS budget rather than an uncounted one inside
@@ -474,8 +478,9 @@ module Basecamp
 
           delay = calculate_delay(attempt, error.retry_after)
 
-          @hooks.on_retry(RequestInfo.new(method: method.to_s.upcase, url: url, attempt: attempt), attempt + 1, error,
-                          delay)
+          hook_url = download ? Security.display_url(url) : url
+          @hooks.on_retry(RequestInfo.new(method: method.to_s.upcase, url: hook_url, attempt: attempt),
+                          attempt + 1, error, delay)
           sleep(delay)
         end
       end
@@ -511,14 +516,19 @@ module Basecamp
     end
 
     def single_request(method, url, params:, body:, attempt:, retry_count: 0, allow_cross_origin: false,
-      accept: "application/json", refresh_replay: true)
+      accept: "application/json", refresh_replay: true, download: false)
       assert_credential_origin!(url, allow_cross_origin)
-      info = RequestInfo.new(method: method.to_s.upcase, url: url, attempt: attempt)
+      # download: the SPEC §9 projection for a URL whose query can carry a
+      # credential (download hop 1) — hooks see origin+path, and a transport
+      # error is severed below; the wire request keeps url.
+      info = RequestInfo.new(method: method.to_s.upcase, url: download ? Security.display_url(url) : url,
+                             attempt: attempt)
       @hooks.on_request_start(info)
 
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
-      begin
+      severed = nil
+      result = begin
         response = @faraday.run_request(method, url, body, request_headers(accept: accept)) do |req|
           req.params.merge!(params) if params.any?
         end
@@ -551,17 +561,29 @@ module Basecamp
             && @token_refreshed
           @token_refreshed = false
           return single_request(method, url, params: params, body: body, attempt: attempt, retry_count: retry_count + 1,
-            allow_cross_origin: allow_cross_origin, accept: accept, refresh_replay: refresh_replay)
+            allow_cross_origin: allow_cross_origin, accept: accept, refresh_replay: refresh_replay, download: download)
         end
 
-        raise error
+        # On a download, a status error is raised below the rescue too: the
+        # Faraday exception retains the request (SPEC §9), and raising here
+        # would make it MRI's implicit cause.
+        raise error unless download
+
+        severed = error
       rescue Faraday::Error => e
         duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-        error = Basecamp::NetworkError.new("Connection failed", cause: e)
-        result = RequestResult.new(duration: duration, error: error)
-        @hooks.on_request_end(info, result)
-        raise error
+        # SPEC §9: on a download hop 1 the Faraday error can render the URL it
+        # failed on, so it is neither the cause nor the hint, and it is raised
+        # below — outside this rescue, with cause: nil — so MRI's implicit
+        # cause is severed too. Every other request keeps its diagnostic.
+        error = download ? Basecamp::NetworkError.new : Basecamp::NetworkError.new("Connection failed", cause: e)
+        @hooks.on_request_end(info, RequestResult.new(duration: duration, error: error))
+        raise error unless download
+
+        severed = error
       end
+
+      severed ? raise(severed, cause: nil) : result
     end
 
     # accept: nil is the binary-download carve-out (SPEC §14): hop 1 sends
@@ -624,38 +646,48 @@ module Basecamp
 
       retry_after = parse_retry_after(headers["Retry-After"] || headers["retry-after"])
       request_id = headers["X-Request-Id"] || headers["x-request-id"]
+      # SPEC §6 step 3: a body's error_description becomes the hint. Class
+      # defaults (AuthError, ForbiddenError) still apply when the body has none.
+      hint = Basecamp.parse_error_hint(body)
 
       err = case status
       when 401
         # Try token refresh; flag for caller to retry
         @token_refreshed = refresh_on_401 && @token_provider&.refreshable? && @token_provider.refresh
-        Basecamp::AuthError.new("Authentication failed")
+        Basecamp::AuthError.new("Authentication failed", hint: hint)
       when 403
-        Basecamp::ForbiddenError.new("Access denied")
+        Basecamp::ForbiddenError.new("Access denied", hint: hint)
       when 404
         message = Security.truncate(Basecamp.parse_error_message(body) || "Not found")
-        Basecamp::NotFoundError.new(message: message)
+        Basecamp::NotFoundError.new(message: message, hint: hint)
       when 429
-        Basecamp::RateLimitError.new(retry_after: retry_after)
+        Basecamp::RateLimitError.new(retry_after: retry_after, hint: hint)
       when 400, 422
         field_errors = Basecamp.parse_field_errors(body)
         message = Security.truncate(
           Basecamp.compose_validation_message(Basecamp.parse_error_message(body), field_errors) || "Validation failed"
         )
-        Basecamp::ValidationError.new(message, http_status: status, field_errors: field_errors)
+        people = status == 422 ? Basecamp.parse_template_library_confirmation_people(body) : nil
+        if people
+          Basecamp::PeopleConfirmationRequiredError.new(
+            message, people: people, hint: hint, http_status: status, field_errors: field_errors
+          )
+        else
+          Basecamp::ValidationError.new(message, hint: hint, http_status: status, field_errors: field_errors)
+        end
       when 507
         # A 5xx status carrying a client fact: the account is out of storage, or
         # at its webhook ceiling. Retrying cannot satisfy it, so this is decided
         # before the 5xx arms below.
         message = Security.truncate(Basecamp.parse_error_message(body) || "Account limit reached")
-        Basecamp::LimitExceededError.new(message)
+        Basecamp::LimitExceededError.new(message, hint: hint)
       when 500
-        Basecamp::ApiError.new("Server error (500)", http_status: 500, retryable: true)
+        Basecamp::ApiError.new("Server error (500)", http_status: 500, retryable: true, hint: hint)
       when 502, 503, 504
-        Basecamp::ApiError.new("Gateway error (#{status})", http_status: status, retryable: true)
+        Basecamp::ApiError.new("Gateway error (#{status})", http_status: status, retryable: true, hint: hint)
       else
         message = Security.truncate(Basecamp.parse_error_message(body) || "Request failed (HTTP #{status})")
-        Basecamp::ApiError.from_status(status || 0, message)
+        Basecamp::ApiError.from_status(status || 0, message, hint: hint)
       end
 
       err.instance_variable_set(:@request_id, request_id) if request_id

data/lib/basecamp/oauth/exchange.rb

@@ -2,16 +2,53 @@
 
 require "faraday"
 require "json"
+require "timeout"
 require "uri"
 
 module Basecamp
   module Oauth
     # Handles OAuth 2 token exchange and refresh operations.
+    #
+    # Both operations POST credentials — the authorization code and client
+    # secret, or the refresh token — to a token endpoint the caller names,
+    # which may be one that discovery's metadata chose. The POST therefore
+    # rides the same hardened transport discipline as the device flow
+    # (SPEC §16 "Token-Endpoint Transport Policy"): redirects are refused
+    # rather than followed, the whole request is wall-clock bounded, and the
+    # body reads under the shared streaming cap.
     class Exchange
-      # @param http_client [Faraday::Connection, nil] HTTP client (uses default if nil)
-      # @param timeout [Integer] Request timeout in seconds (default: 30)
-      def initialize(http_client: nil, timeout: 30)
-        @http_client = http_client || build_default_client(timeout)
+      # The redirect statuses a token endpoint response is refused for
+      # (SPEC §16 "Token-Endpoint Transport Policy") — the same set the signed
+      # download hop refuses (SPEC §14). 304 is deliberately absent: it is a
+      # cache validator, not a redirect-with-Location, and stays on the
+      # generic non-success path.
+      REDIRECT_STATUSES = [ 301, 302, 303, 307, 308 ].freeze
+
+      # Default per-request timeout in seconds — the shared credential-POST
+      # default every SDK's token and device POSTs converge on (SPEC §16).
+      DEFAULT_TIMEOUT = 30
+
+      # Cap on a token response body (1 MiB), matching the device flow's and
+      # the other SDKs' token-response bound.
+      MAX_BODY_BYTES = 1 * 1024 * 1024
+
+      # @param http_client [Faraday::Connection, nil] HTTP client. Nil selects
+      #   the headers-first default transport ({Fetcher.stream_http}); an
+      #   injected connection is refused unless its stack is verifiably
+      #   redirect-free (adapter-only), and keeps the injected-client fidelity
+      #   tier: status classification only after the (bounded) read completes,
+      #   deadline enforced wall-clock around the call.
+      # @param timeout [Numeric] Request timeout in seconds (default: 30).
+      #   Invalid values and values beyond the shared 3600 s ceiling fall back
+      #   to the default rather than disabling the bound.
+      def initialize(http_client: nil, timeout: DEFAULT_TIMEOUT)
+        # An injected connection is the caller's transport, but redirect
+        # suppression is not negotiable on a credential POST: refuse a stack
+        # that could follow (or rewrite) before any request is issued — the
+        # same guard discovery, resource, and the device flow apply.
+        Fetcher.ensure_redirects_suppressed!(http_client) if http_client
+        @http_client = http_client
+        @timeout = Fetcher.normalize_timeout(timeout, default: DEFAULT_TIMEOUT)
       end
 
       # Exchanges an authorization code for access and refresh tokens.
@@ -80,14 +117,6 @@ module Basecamp
 
       private
 
-      def build_default_client(timeout)
-        Faraday.new do |conn|
-          conn.options.timeout = timeout
-          conn.options.open_timeout = timeout
-          conn.adapter Faraday.default_adapter
-        end
-      end
-
       def validate_exchange_request!(request)
         raise OauthError.new("validation", "Token endpoint is required") if request.token_endpoint.to_s.empty?
         raise OauthError.new("validation", "Authorization code is required") if request.code.to_s.empty?
@@ -145,30 +174,128 @@ module Basecamp
       def do_token_request(token_endpoint, params)
         Basecamp::Security.require_https_unless_localhost!(token_endpoint, "token endpoint")
 
-        response = @http_client.post(token_endpoint) do |req|
-          req.headers["Content-Type"] = "application/x-www-form-urlencoded"
-          req.headers["Accept"] = "application/json"
-          req.body = URI.encode_www_form(params)
+        status, body = post_form(
+          token_endpoint, params,
+          skip_status: ->(s) { REDIRECT_STATUSES.include?(s) }
+        )
+
+        # A refused redirect is a typed verdict classified by status alone —
+        # its body (skipped above) is never a token, and the credential POST
+        # is never re-issued toward Location (SPEC §16).
+        if REDIRECT_STATUSES.include?(status)
+          raise OauthError.new(
+            "api_error",
+            "redirect #{status} on the token endpoint is not followed",
+            http_status: status
+          )
         end
 
-        parse_token_response(response)
+        parse_token_response(status, body)
       rescue Faraday::TimeoutError
         raise OauthError.new("network", "Token request timed out", retryable: true)
       rescue Faraday::Error => e
         raise OauthError.new("network", "Token request failed: #{e.message}", retryable: true)
       end
 
-      def parse_token_response(response)
-        Basecamp::Security.check_body_size!(response.body, Basecamp::Security::MAX_ERROR_BODY_BYTES, "Token")
+      # POSTs the token form and returns +[status, body]+, reading under the
+      # same bounded/streaming cap as discovery and the device flow.
+      #
+      # With no injected client the POST runs on the headers-first
+      # {Fetcher.stream_http} primitive: +skip_status+ classifies a redirect
+      # by status at HEADER time (its body is never read, even one that
+      # stalls forever), redirects are structurally never followed, and a
+      # watchdog bounds the whole request — a stalled or byte-dripped header
+      # phase included — at the timeout. An INJECTED Faraday connection keeps
+      # the Faraday path below.
+      def post_form(url, params, skip_status:)
+        if @http_client.nil?
+          Fetcher.stream_http(
+            :post, url,
+            headers: { "Content-Type" => "application/x-www-form-urlencoded", "Accept" => "application/json" },
+            form: params, timeout: @timeout, max_body_bytes: MAX_BODY_BYTES, skip_status: skip_status
+          )
+        else
+          post_form_injected(url, params, skip_status)
+        end
+      rescue Fetcher::SkipBody => e
+        # The body was intentionally not drained (a redirect's body is never a
+        # token) — classify by status upstream.
+        [ e.status, "" ]
+      rescue Fetcher::BodyTooLarge
+        raise OauthError.new("api_error", "Token response exceeds size cap")
+      rescue Fetcher::ReadDeadlineExceeded
+        # A slow-drip read is a transport timeout, not an api_error — surface
+        # as the Faraday timeout the caller's rescue classifies.
+        raise Faraday::TimeoutError, "Token request read exceeded the timeout deadline"
+      end
+
+      # Injected-client (Faraday) lane — the injected-client fidelity tier
+      # (SPEC §16): the same invariants as the default transport (suppressed
+      # redirects, bounded body, whole-request wall clock), with buffered
+      # classification. +req.options.timeout+ below bounds only each socket
+      # read and resets on every +on_data+ chunk, so a slow-drip peer could
+      # otherwise hold the credential POST open past the timeout while
+      # staying under the cap — the monotonic deadline bounds the WHOLE
+      # request, and +Timeout.timeout+ enforces it through a stalled or
+      # dripped HEADER phase, where +on_data+ (a body callback) never runs.
+      def post_form_injected(url, params, skip_status)
+        deadline = Fetcher.monotonic_now + @timeout
+        chunks, on_data = Fetcher.bounded_reader(MAX_BODY_BYTES, deadline: deadline, skip_status: skip_status)
+        # The window is the REMAINING budget, not a fresh timeout: time spent
+        # before dispatch already counts against the deadline, so the request
+        # can never run past it.
+        remaining = deadline - Fetcher.monotonic_now
+        raise Faraday::TimeoutError, "request budget exhausted before dispatch" if remaining <= 0
+
+        response = Timeout.timeout(remaining, Faraday::TimeoutError) do
+          @http_client.post(url) do |req|
+            req.headers["Content-Type"] = "application/x-www-form-urlencoded"
+            req.headers["Accept"] = "application/json"
+            req.body = URI.encode_www_form(params)
+            req.options.timeout = @timeout
+            req.options.open_timeout = @timeout
+            req.options.on_data = on_data
+          end
+        end
+
+        # Status-first backstop on the completed response: the +on_data+
+        # SkipBody fast-path only fires when the adapter streams AND passes
+        # +env+ (Faraday >= 2.5). A buffered adapter that ignores +on_data+,
+        # an older Faraday (2.0–2.4) that omits +env+, or a header-only
+        # response reaches here with the redirect body un-skipped — re-apply
+        # +skip_status+ to the final status so a redirect is classified by
+        # status for every client shape, never buffered into a size-cap error.
+        # A definitive completed status outranks the deadline re-check below;
+        # everything else completing past the deadline is refused as the same
+        # transport-shaped timeout (Timeout.timeout's interrupt can land late).
+        if skip_status.call(response.status)
+          [ response.status, "" ]
+        elsif Fetcher.monotonic_now > deadline
+          raise Faraday::TimeoutError, "response completed after the deadline"
+        else
+          body =
+            if chunks.empty?
+              raw = response.body.to_s
+              raise Fetcher::BodyTooLarge if raw.bytesize > MAX_BODY_BYTES
+
+              raw
+            else
+              chunks.join
+            end
+
+          [ response.status, body.dup.force_encoding(Encoding::UTF_8) ]
+        end
+      end
 
-        data = JSON.parse(response.body)
+      def parse_token_response(status, body)
+        data = JSON.parse(body)
 
-        handle_error_response(response.status, data) unless response.success?
+        handle_error_response(status, data) unless (200..299).cover?(status)
 
         unless data["access_token"].is_a?(String) && !data["access_token"].empty?
           raise OauthError.new(
             "api_error", "Token response missing or non-string access_token",
-            http_status: response.status
+            http_status: status
           )
         end
 
@@ -179,7 +306,7 @@ module Basecamp
           raise OauthError.new(
             "api_error",
             "Token response resource must be a non-empty string when present",
-            http_status: response.status
+            http_status: status
           )
         end
 
@@ -191,7 +318,7 @@ module Basecamp
           raise OauthError.new(
             "api_error",
             "Token response token_type must be a non-empty string when present",
-            http_status: response.status
+            http_status: status
           )
         end
 
@@ -213,7 +340,7 @@ module Basecamp
         raise OauthError.new(
           "api_error",
           "Failed to parse token response",
-          http_status: response.status
+          http_status: status
         ), cause: nil
       end
 

data/lib/basecamp/oauth/fetcher.rb

@@ -239,7 +239,7 @@ module Basecamp
 
         raise OauthError.new(
           "validation",
-          "Injected OAuth discovery client must carry only an adapter (no middleware); " \
+          "Injected OAuth client must carry only an adapter (no middleware); " \
           "found #{offending.klass.name}. Redirects are suppressed for SSRF safety, so a " \
           "connection whose middleware stack cannot be verified redirect-free is refused"
         )