anthropic 1.48.2 → 1.49.0

data/lib/anthropic/helpers/vertex/client.rb

@@ -37,6 +37,11 @@ module Anthropic
         #
         # @param max_retry_delay [Float] The maximum number of seconds to wait before retrying a request
         #
+        # @param middleware [Array<#call>, #call, nil] Per-attempt HTTP around-middleware. See
+        #   {Anthropic::Middleware}. Middleware sees the canonical Anthropic request shape;
+        #   the Vertex URL rewrite and OAuth header happen inside the continuation, per
+        #   attempt.
+        #
         def initialize(
           region: ENV["CLOUD_ML_REGION"],
           project_id: ENV["ANTHROPIC_VERTEX_PROJECT_ID"],
@@ -44,7 +49,8 @@ module Anthropic
           max_retries: DEFAULT_MAX_RETRIES,
           timeout: DEFAULT_TIMEOUT_IN_SECONDS,
           initial_retry_delay: DEFAULT_INITIAL_RETRY_DELAY,
-          max_retry_delay: DEFAULT_MAX_RETRY_DELAY
+          max_retry_delay: DEFAULT_MAX_RETRY_DELAY,
+          middleware: nil
         )
           begin
             require("googleauth")
@@ -81,6 +87,7 @@ module Anthropic
             raise ArgumentError.new(message)
           end
           @project_id = project_id
+          @authorization = nil
 
           base_url ||= ENV.fetch(
             "ANTHROPIC_VERTEX_BASE_URL",
@@ -102,6 +109,7 @@ module Anthropic
             max_retries: max_retries,
             initial_retry_delay: initial_retry_delay,
             max_retry_delay: max_retry_delay,
+            middleware: middleware
           )
 
           @messages = Anthropic::Resources::Messages.new(client: self)
@@ -146,58 +154,81 @@ module Anthropic
         #
         # @return [Hash{Symbol=>Object}]
         private def build_request(req, opts)
-          fit_req_to_vertex_specs!(req)
-
-          request_input = super
-
-          headers = request_input.fetch(:headers)
-
-          unless headers.key?("authorization")
-            authorization = Google::Auth.get_application_default(["https://www.googleapis.com/auth/cloud-platform"])
-            request_input.store(:headers, authorization.apply(headers))
+          # Id-parameterized routes pass `path` as an Array whose first element
+          # is the format string (e.g. `["v1/messages/batches/%1$s", id]`).
+          path = Array(req[:path]).first.to_s
+          if path.start_with?("v1/messages/batches")
+            raise NotImplementedError.new("The Batch API is not supported in the Vertex client yet")
           end
 
-          request_input
+          super
         end
 
-        # @private
-        #
-        # Overrides request components for Vertex-specific request-shape requirements.
-        #
-        # @param request_components [Hash{Symbol=>Object}] .
-        #
-        #   @option request_components [Symbol] :method
-        #
-        #   @option request_components [String, Array<String>] :path
-        #
-        #   @option request_components [Hash{String=>Array<String>, String, nil}, nil] :query
-        #
-        #   @option request_components [Hash{String=>String, nil}, nil] :headers
-        #
-        #   @option request_components [Object, nil] :body
+        # @api private
         #
-        #   @option request_components [Symbol, nil] :unwrap
+        # The Vertex provider middleware: rewrites the canonical request into
+        # Vertex's shape and applies the Google OAuth `authorization` header.
+        # Appended innermost on every dispatch (below user middleware) and runs
+        # per attempt, so a middleware that re-issues the request gets a fresh
+        # token per leg, mirroring the Bedrock SigV4 placement.
         #
-        #   @option request_components [Class, nil] :page
+        # @return [#call]
+        private def provider_middleware
+          lambda do |req, nxt|
+            nxt.call(apply_google_auth(adapt_request(req)))
+          end
+        end
+
+        # @api private
         #
-        #   @option request_components [Anthropic::Converter, Class, nil] :model
+        # @param req [Anthropic::APIRequest]
+        # @return [Anthropic::APIRequest]
+        private def apply_google_auth(req)
+          return req if req.headers.key?("authorization")
+          # `follow_redirect` stripped `authorization` for a cross-origin hop —
+          # don't re-add it and leak the bearer token to the new origin.
+          return req if req.metadata[:cross_origin_redirect]
+
+          # Memoized: the credentials object caches its token and self-refreshes
+          # on expiry, so each retry leg still gets a fresh-enough token without
+          # re-resolving ADC (a blocking metadata-server/token-endpoint
+          # round-trip) on every attempt.
+          authorization =
+            @authorization ||= Google::Auth.get_application_default(["https://www.googleapis.com/auth/cloud-platform"])
+          # `req.headers` may be the deep-frozen hash a middleware saw, and
+          # googleauth's `#apply` does `clone` (which preserves frozen) then
+          # `[]=` — so it must be handed a fresh, mutable copy.
+          req.with(headers: authorization.apply({**req.headers}))
+        end
+
+        # @api private
         #
-        # @return [Hash{Symbol=>Object}]
-        private def fit_req_to_vertex_specs!(request_components)
-          if (body = request_components[:body]).is_a?(Hash)
+        # Rewrites the canonical Anthropic request into Vertex's shape — drops
+        # `:model` from the body (keeping `:stream`) and retargets the URL to
+        # `projects/{project}/locations/{region}/publishers/anthropic/models/{model}:{rawPredict|streamRawPredict}`.
+        # Called from {#provider_middleware}, so user middleware sees the
+        # canonical request. Pure: the incoming request, its body, headers,
+        # and URI are never mutated (they are reused across retry attempts).
+        #
+        # @param req [Anthropic::APIRequest]
+        # @return [Anthropic::APIRequest]
+        private def adapt_request(req)
+          body = req.body
+          headers = req.headers
+          url = req.url
+          path = url.path.to_s
+          query_ok = url.query.nil? || url.query == "beta=true"
+
+          if body.is_a?(Hash)
+            body = body.dup
             body[:anthropic_version] ||= DEFAULT_VERSION
 
             if (anthropic_beta = body.delete(:"anthropic-beta"))
-              request_components[:headers] ||= {}
-              request_components[:headers]["anthropic-beta"] = anthropic_beta.join(",")
+              headers = headers.merge("anthropic-beta" => Array(anthropic_beta).join(","))
             end
           end
 
-          if %w[
-            v1/messages
-            v1/messages?beta=true
-          ].include?(request_components[:path]) && request_components[:method] == :post
-
+          if req.method == :post && query_ok && path.end_with?("/v1/messages")
             unless body.is_a?(Hash)
               raise ArgumentError.new("Expected json data to be a hash for post /v1/messages")
             end
@@ -205,26 +236,39 @@ module Anthropic
             model = body.delete(:model)
             specifier = body[:stream] ? "streamRawPredict" : "rawPredict"
 
-            request_components[:path] =
+            url = rewrite_path(
+              url,
+              %r{v1/messages\z},
               "projects/#{@project_id}/locations/#{region}/publishers/anthropic/models/#{model}:#{specifier}"
-
+            )
+          elsif req.method == :post && query_ok && path.end_with?("/v1/messages/count_tokens")
+            url = rewrite_path(
+              url,
+              %r{v1/messages/count_tokens\z},
+              "projects/#{@project_id}/locations/#{region}/publishers/anthropic/" \
+              "models/count-tokens:rawPredict"
+            )
           end
 
-          if %w[
-            v1/messages/count_tokens
-            v1/messages/count_tokens?beta=true
-          ].include?(request_components[:path]) &&
-             request_components[:method] == :post
-            request_components[:path] =
-              "projects/#{@project_id}/locations/#{region}/publishers/anthropic/models/count-tokens:rawPredict"
-
-          end
-
-          if request_components[:path].start_with?("v1/messages/batches/")
-            raise AnthropicError("The Batch API is not supported in the Vertex client yet")
-          end
+          return req if body.equal?(req.body) && headers.equal?(req.headers) && url.equal?(req.url)
+          req.with(body: body, headers: headers, url: url)
+        end
 
-          request_components
+        # @api private
+        #
+        # Retarget `url`'s path (replacing `pattern` with `replacement`) and drop
+        # its query, returning a fresh copy so the incoming request's URI is left
+        # untouched.
+        #
+        # @param url [URI::Generic]
+        # @param pattern [Regexp]
+        # @param replacement [String]
+        # @return [URI::Generic]
+        private def rewrite_path(url, pattern, replacement)
+          url = url.dup
+          url.path = url.path.to_s.sub(pattern, replacement)
+          url.query = nil
+          url
         end
       end
     end

data/lib/anthropic/internal/transport/base_client.rb

@@ -132,7 +132,14 @@ module Anthropic
             # from undici
             if Anthropic::Internal::Util.uri_origin(url) != Anthropic::Internal::Util.uri_origin(location)
               drop = %w[authorization cookie host proxy-authorization]
-              request = {**request, headers: request.fetch(:headers).except(*drop)}
+              # The sentinel keeps the strip durable: provider middleware
+              # (Vertex OAuth, Bedrock SigV4) runs per attempt and would
+              # otherwise re-add `authorization` on the redirected leg.
+              request = {
+                **request,
+                headers: request.fetch(:headers).except(*drop),
+                metadata: {**request.fetch(:metadata, {}), cross_origin_redirect: true}
+              }
             end
 
             request
@@ -178,6 +185,9 @@ module Anthropic
         # @return [Anthropic::Internal::Transport::PooledNetRequester]
         attr_reader :requester
 
+        # @return [Array<#call>] the middleware chain (first = outermost).
+        attr_reader :middleware
+
         # @api private
         #
         # @param base_url [String]
@@ -187,6 +197,8 @@ module Anthropic
         # @param max_retry_delay [Float]
         # @param headers [Hash{String=>String, Integer, Array<String, Integer, nil>, nil}]
         # @param idempotency_header [String, nil]
+        # @param middleware [Array<#call>, #call, nil]
+        # @param requester [Anthropic::Internal::Transport::PooledNetRequester, nil]
         def initialize(
           base_url:,
           timeout: 0.0,
@@ -194,9 +206,12 @@ module Anthropic
           initial_retry_delay: 0.0,
           max_retry_delay: 0.0,
           headers: {},
-          idempotency_header: nil
+          idempotency_header: nil,
+          middleware: nil,
+          requester: nil
         )
-          @requester = Anthropic::Internal::Transport::PooledNetRequester.new
+          @middleware = Array(middleware).freeze
+          @requester = requester || Anthropic::Internal::Transport::PooledNetRequester.new
           @headers = Anthropic::Internal::Util.normalized_headers(
             self.class::PLATFORM_HEADERS,
             {
@@ -316,15 +331,30 @@ module Anthropic
             @base_url_components,
             {**req, path: path, query: query}
           )
-          headers, encoded = Anthropic::Internal::Util.encode_content(headers, body)
+
+          # Per-request middleware rides in `request_options` but is kept out of
+          # the `options` view a middleware sees — it is the live chain, not
+          # serializable request configuration, and surfacing it there would be
+          # self-referential.
+          request_middleware = Array(opts[:middleware])
+
           {
             method: method,
             url: url,
             headers: headers,
-            body: encoded,
+            body: body,
             max_retries: opts.fetch(:max_retries, @max_retries),
             timeout: timeout,
-            user_header_keys: user_header_keys
+            user_header_keys: user_header_keys,
+            # For paginated requests `model` is the page's *item* type, not the
+            # response envelope's — middleware `parse` falls back to the raw
+            # decoded page data instead of mis-coercing.
+            cast_to: req[:page] ? nil : req.fetch(:model, Anthropic::Internal::Type::Unknown),
+            stream: req[:stream],
+            unwrap: req[:unwrap],
+            options: opts.except(:middleware),
+            middleware: request_middleware,
+            metadata: {}
           }
         end
 
@@ -356,20 +386,24 @@ module Anthropic
 
         # @api private
         #
-        # Very private API, do not use
+        # The default innermost middleware. 3p provider clients
+        # (Bedrock/Vertex/AWS) override this to return a `#call(req, nxt)`
+        # entry that rewrites the canonical Anthropic request into the
+        # provider's wire shape and applies provider auth (SigV4 signing,
+        # OAuth tokens).
         #
-        # @param request [Hash{Symbol=>Object}] .
+        # It is appended below all user middleware on every dispatch — client-
+        # and request-level entries alike always see the canonical request
+        # (`body[:model]`, `/v1/messages` URL) regardless of provider
+        # ("3p-inner" ordering) — and, like any middleware, runs per attempt, so
+        # SDK retries and middleware-re-issued requests are re-adapted and
+        # re-signed for their own leg.
         #
-        #   @option request [Symbol] :method
+        # The requests it receives are reused across retry attempts — it MUST
+        # be pure and must not mutate `req` or any object reachable from it.
         #
-        #   @option request [URI::Generic] :url
-        #
-        #   @option request [Hash{String=>String}] :headers
-        #
-        #   @option request [Object] :body
-        #
-        # @return [Hash{Symbol, Object}]
-        private def transform_request(request) = request
+        # @return [#call, nil]
+        private def provider_middleware = nil
 
         # @api private
         #
@@ -381,6 +415,28 @@ module Anthropic
           self.class.should_retry?(status, headers: headers)
         end
 
+        # @api private
+        #
+        # Whether `err` (or any error reachable via `Exception#cause`) is one
+        # the SDK retries — {Anthropic::Errors::RetryableError},
+        # {Anthropic::Errors::APIConnectionError}, or its subclass
+        # {Anthropic::Errors::APITimeoutError}.
+        #
+        # @param err [Exception]
+        # @return [Boolean]
+        private def retryable_error?(err)
+          seen = {}.compare_by_identity
+          while err && !seen[err]
+            seen[err] = true
+            case err
+            when Anthropic::Errors::RetryableError, Anthropic::Errors::APIConnectionError
+              return true
+            end
+            err = err.cause
+          end
+          false
+        end
+
         # @api private
         #
         # @param request [Hash{Symbol=>Object}] .
@@ -404,42 +460,137 @@ module Anthropic
         # @param send_retry_header [Boolean]
         #
         # @raise [Anthropic::Errors::APIError]
-        # @return [Array(Integer, Net::HTTPResponse, Enumerable<String>)]
+        # @return [Array(Integer, Net::HTTPResponse|nil, Hash{String=>String}, Enumerable<String>)]
         def send_request(request, redirect_count:, retry_count:, send_retry_header:)
           if send_retry_header
             request.fetch(:headers)["x-stainless-retry-count"] = retry_count.to_s
           end
 
-          request = transform_request(request)
           url, max_retries, timeout = request.fetch_values(:url, :max_retries, :timeout)
-          input = {**request.except(:timeout), deadline: Anthropic::Internal::Util.monotonic_secs + timeout}
+
+          # Request-level middleware (from `request_options`) runs innermost
+          # among user middleware — below client-level entries, above the
+          # provider middleware.
+          request_middleware = request.fetch(:middleware, [])
+
+          # Per-attempt defensive copies: the `request` hash and its members are
+          # reused across retry recursions (the SDK mutates `request[:headers]`
+          # for retry-count/auth stamping), so the immutable view middleware sees
+          # must not alias them. With no user middleware at all only the terminal
+          # and the provider middleware read these (both are pure), so the deep
+          # freeze is skipped. Only `headers` change across retries, so the frozen
+          # `url`/`body`/`options` copies are cached on `request` and reused; the
+          # redirect path drops the stale `url`/`body` copies. `metadata` is the
+          # deliberate exception — it is the cross-attempt scratchpad a middleware
+          # may write to.
+          user_middleware_empty = @middleware.empty? && request_middleware.empty?
+          freeze = user_middleware_empty ? ->(o) { o } : Anthropic::Internal::Util.method(:deep_frozen_copy)
+          api_req = Anthropic::APIRequest.new(
+            method: request.fetch(:method),
+            url: (request[:frozen_url] ||= freeze.call(url)),
+            headers: freeze.call(request.fetch(:headers)),
+            body: (request[:frozen_body] ||= freeze.call(request[:body])),
+            stream: request[:stream],
+            cast_to: request[:cast_to],
+            unwrap: request[:unwrap],
+            options: (
+              request[:frozen_options] ||= freeze.call(request.fetch(:options, {}).merge(timeout: timeout))
+            ),
+            retry_count: retry_count,
+            metadata: request.fetch(:metadata, {})
+          )
+
+          # The provider request the response actually came from — captured
+          # inside the terminal so error reporting, relative-redirect
+          # resolution, and redirect re-sends see the post-`provider_middleware`
+          # (Bedrock/Vertex) URL and body, not the canonical `/v1/messages`
+          # shape. Falls back to the canonical values when middleware
+          # short-circuits before `nxt.call`.
+          adapted_url = url
+          adapted_body = request[:body]
+          attempt_body = nil
+          attempt_headers = nil
+          terminal = lambda do |r|
+            adapted_url = r.url
+            adapted_body = r.body
+            enc_headers, encoded = Anthropic::Internal::Util.encode_content(r.headers, r.body)
+            input = {
+              method: r.method,
+              url: r.url,
+              headers: enc_headers,
+              body: encoded,
+              deadline: Anthropic::Internal::Util.monotonic_secs + timeout
+            }
+            http_status, raw, body = @requester.execute(input)
+            attempt_body = body
+            res = Anthropic::APIResponse.wrap(http_status, raw, body, request: r)
+            attempt_headers = res.headers
+            res
+          end
 
           begin
-            status, response, stream = @requester.execute(input)
-          rescue Anthropic::Errors::APIConnectionError => e
+            chain = Anthropic::Middleware.build_chain(
+              [*@middleware, *request_middleware, *provider_middleware],
+              terminal
+            )
+            mres = chain.call(api_req)
+            unless mres.is_a?(Anthropic::APIResponse)
+              raise TypeError,
+                    "middleware returned #{mres.class}, expected Anthropic::APIResponse"
+            end
+            status, response, headers, stream = mres.to_tuple
+          rescue StandardError => e
+            # A middleware may raise after `nxt.call` returned a live response
+            # (e.g. `raise RetryableError if res.status >= 500`); release the
+            # pooled connection its un-consumed body still holds.
+            Anthropic::Internal::Util.close_fused!(attempt_body)
+            raise unless retryable_error?(e)
             status = e
+            # A middleware may raise after observing a live response (e.g. a 429
+            # carrying `Retry-After`); keep that response's headers so retry
+            # backoff still honors server-driven delay. `nil` when the terminal
+            # itself raised — a connection failure carries no response.
+            headers = attempt_headers || {}
           end
-          headers = Anthropic::Internal::Util.normalized_headers(response&.each_header&.to_h)
 
           case status
           in ..299
-            [status, response, stream]
+            [status, response, headers, stream]
           in 300..399 if redirect_count >= self.class::MAX_REDIRECTS
             self.class.reap_connection!(status, stream: stream)
 
             message = "Failed to complete the request within #{self.class::MAX_REDIRECTS} redirects."
-            raise Anthropic::Errors::APIConnectionError.new(url: url, response: response, message: message)
+            raise Anthropic::Errors::APIConnectionError.new(
+              url: adapted_url,
+              response: response,
+              message: message
+            )
           in 300..399
             self.class.reap_connection!(status, stream: stream)
 
-            request = self.class.follow_redirect(request, status: status, response_headers: headers)
+            # Re-send the provider-adapted body: the redirect target is a
+            # provider URL that fails the provider middleware's adapt gate, so
+            # the canonical body would otherwise go out un-adapted on
+            # Bedrock/Vertex. A SigV4-signed `StringIO` body was consumed by
+            # the prior attempt and must be rewound before re-signing.
+            adapted_body.rewind if adapted_body.is_a?(StringIO) || adapted_body.is_a?(IO)
+            request = self.class.follow_redirect(
+              request.merge(url: adapted_url, body: adapted_body),
+              status: status,
+              response_headers: headers
+            )
+            # The redirect retargets the URL, and `follow_redirect` may drop the
+            # body (303 → GET); the cached frozen copies would then be stale, so
+            # they are recomputed on the redirected attempt.
+            request.delete(:frozen_body)
+            request.delete(:frozen_url)
             send_request(
               request,
               redirect_count: redirect_count + 1,
               retry_count: retry_count,
               send_retry_header: send_retry_header
             )
-          in Anthropic::Errors::APIConnectionError if retry_count >= max_retries
+          in Exception if retry_count >= max_retries
             raise status
           in (400..) if retry_count >= max_retries || !retry_request?(status, headers: headers)
             decoded = Kernel.then do
@@ -449,17 +600,17 @@ module Anthropic
             end
 
             raise Anthropic::Errors::APIStatusError.for(
-              url: url,
+              url: adapted_url,
               status: status,
               headers: headers,
               body: decoded,
               request: nil,
               response: response
             )
-          in (400..) | Anthropic::Errors::APIConnectionError
+          in (400..) | Exception
             self.class.reap_connection!(status, stream: stream)
 
-            delay = retry_delay(response || {}, retry_count: retry_count)
+            delay = retry_delay(headers, retry_count: retry_count)
             sleep(delay)
 
             # Refresh auth headers across retries: credential providers (e.g. OAuth
@@ -533,14 +684,13 @@ module Anthropic
 
           # Don't send the current retry count in the headers if the caller modified the header defaults.
           send_retry_header = request.fetch(:headers)["x-stainless-retry-count"] == "0"
-          status, response, stream = send_request(
+          status, response, headers, stream = send_request(
             request,
             redirect_count: 0,
             retry_count: 0,
             send_retry_header: send_retry_header
           )
 
-          headers = Anthropic::Internal::Util.normalized_headers(response.each_header.to_h)
           decoded = Anthropic::Internal::Util.decode_content(headers, stream: stream)
           case req
           in {stream: Class => st}
@@ -613,7 +763,20 @@ module Anthropic
               body: T.anything,
               max_retries: Integer,
               timeout: Float,
-              user_header_keys: T::Array[String]
+              user_header_keys: T::Array[String],
+              cast_to: T.nilable(Anthropic::Internal::Type::Converter::Input),
+              stream: T.nilable(T::Class[T.anything]),
+              unwrap: T.nilable(
+                T.any(
+                  Symbol,
+                  Integer,
+                  T::Array[T.any(Symbol, Integer)],
+                  T.proc.params(arg0: T.anything).returns(T.anything)
+                )
+              ),
+              options: T::Hash[Symbol, T.anything],
+              middleware: T::Array[T.anything],
+              metadata: T::Hash[Symbol, T.anything]
             }
           end
         end

data/lib/anthropic/internal/util.rb

@@ -27,6 +27,38 @@ module Anthropic
       end
 
       class << self
+        # @api private
+        #
+        # Structurally copy and freeze `obj` (Hash/Array recursively; mutable
+        # `String` leaves dup-frozen; `URI::Generic` re-parsed with each
+        # component string frozen) so the result is fully de-aliased from the
+        # input and any in-place mutation raises `FrozenError`. Other leaves
+        # (Integer/Symbol — already frozen; typed models; IO) pass through, IO
+        # because it must stay live for streamed uploads.
+        #
+        # @param obj [Object]
+        # @return [Object]
+        def deep_frozen_copy(obj)
+          case obj
+          when Hash
+            obj.transform_values { deep_frozen_copy(_1) }.freeze
+          when Array
+            obj.map { deep_frozen_copy(_1) }.freeze
+          when String
+            obj.frozen? ? obj : obj.dup.freeze
+          when URI::Generic
+            # Re-parse de-aliases every component string; freezing each via its
+            # public reader (then the URI) makes `url.path << "x"` raise without
+            # reaching below `URI::Generic`'s public surface. Callers `dup` then
+            # reassign components, so a frozen URI is fine to derive from.
+            URI.parse(obj.to_s).tap do |u|
+              [u.scheme, u.userinfo, u.host, u.path, u.query, u.opaque, u.fragment].each { _1&.freeze }
+            end.freeze
+          else
+            obj
+          end
+        end
+
         # @api private
         #
         # @return [String]
@@ -658,7 +690,11 @@ module Anthropic
             [headers, JSON.generate(body)]
           in [Anthropic::Internal::Util::JSONL_CONTENT, Enumerable] unless Anthropic::Internal::Type::FileInput === body
             [headers, body.lazy.map { JSON.generate(_1) }]
-          in [%r{^multipart/form-data}, Hash | Anthropic::Internal::Type::FileInput]
+          # A `boundary=` already in the content-type means the body was
+          # encoded upstream (e.g. SigV4 signing encodes-then-signs and the
+          # terminal calls this again) — fall through to the pass-through arms
+          # instead of re-wrapping the signed bytes with a second boundary.
+          in [%r{^multipart/form-data}, Hash | Anthropic::Internal::Type::FileInput] unless content_type.include?("boundary=")
             boundary, strio = encode_multipart_streaming(body)
             headers = {**headers, "content-type" => "#{content_type}; boundary=#{boundary}"}
             [headers, strio]