anthropic 1.48.2 → 1.49.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04770f1a0fcb24be2c40a0a67b9397c0103218ff9c082e75d9659c0673ff5aac
-  data.tar.gz: df85394d335c2666281c5c3d05af57465480712df8664a7885721481406e81cc
+  metadata.gz: 45df9830dd4224180e2702068ad79b01ad5f045a6499969bbddfc5a49f29cec9
+  data.tar.gz: f501463bdb25da9354140ada09b8c638064fcf1c57ae751e9156c526b5281acb
 SHA512:
-  metadata.gz: 8940514153f62cefb0878d36dc786f542a0002e38543c3e52dc88d9d32e34f36f99db5c15e4de894a84c39ff361f03711b6a88613dee198343ede2e337bccba2
-  data.tar.gz: f6c21933bb2e77445eff2925250b25315f729c8ae81f45e7a0be304959996d75e19a6398539c4a063380b3376f556b35ac1a1ad16d5ca9f03074e74c642ef939
+  metadata.gz: d4521d3d6191009cd99cd92898d6cfdca44ae99908d06ddaafee22665f21ba4751c6c02c5fb705ddea04827251769b69c53e62734e9edb04f60f9aa7dffe6802
+  data.tar.gz: 7d917f565b12839a5755d0e9638d2d57a05a489bd022d3284f2ba4bd812d488f5b2b635e38f8a3ad12fb24f8c305a7dcb16aed77d9c7ca17f66386183e607c39

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 1.49.0 (2026-06-18)
+
+Full Changelog: [v1.48.2...v1.49.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.48.2...v1.49.0)
+
+### Features
+
+* **api:** add support for new code_execution_20260120 tool ([9e4d388](https://github.com/anthropics/anthropic-sdk-ruby/commit/9e4d388649bb020e66ebac13ae4ad90450a3f293))
+* **client:** add HTTP middleware ([#30](https://github.com/anthropics/anthropic-sdk-ruby/issues/30)) ([e6c7245](https://github.com/anthropics/anthropic-sdk-ruby/commit/e6c7245b1539a08d7ec5ad103f0ee291c2bbcb52))
+
+
+### Bug Fixes
+
+* **bedrock:** decode AWS event-stream framing on streaming responses ([2f8d31c](https://github.com/anthropics/anthropic-sdk-ruby/commit/2f8d31cff8ea7119b6271e926c83733bf8297106))
+
 ## 1.48.2 (2026-06-15)
 
 Full Changelog: [v1.48.1...v1.48.2](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.48.1...v1.48.2)

data/README.md

@@ -15,7 +15,7 @@ Add to your application's Gemfile:
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "anthropic", "~> 1.48.2"
+gem "anthropic", "~> 1.49.0"
 ```
 
 <!-- x-release-please-end -->

data/lib/anthropic/client.rb

@@ -175,6 +175,10 @@ module Anthropic
     # @param initial_retry_delay [Float]
     #
     # @param max_retry_delay [Float]
+    #
+    # @param middleware [Array<#call>, #call, nil] Per-attempt HTTP around-middleware. Each
+    #   entry is a `#call(req, nxt) -> Anthropic::APIResponse` callable. See
+    #   {Anthropic::Middleware}.
     def initialize(
       api_key: nil,
       auth_token: nil,
@@ -185,7 +189,8 @@ module Anthropic
       max_retries: self.class::DEFAULT_MAX_RETRIES,
       timeout: self.class::DEFAULT_TIMEOUT_IN_SECONDS,
       initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
-      max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY
+      max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY,
+      middleware: nil
     )
       if config && credentials
         raise ArgumentError, "Pass at most one of `credentials:` or `config:`."
@@ -265,7 +270,8 @@ module Anthropic
         max_retries: max_retries,
         initial_retry_delay: initial_retry_delay,
         max_retry_delay: max_retry_delay,
-        headers: headers
+        headers: headers,
+        middleware: middleware
       )
 
       @completions = Anthropic::Resources::Completions.new(client: self)

data/lib/anthropic/errors.rb

@@ -8,6 +8,20 @@ module Anthropic
       #   @return [StandardError, nil]
     end
 
+    # Raise from a middleware to explicitly opt a middleware-origin failure
+    # into the SDK's retry loop. Retry classification walks `Exception#cause`,
+    # so a middleware may wrap with its own error class and still have the SDK
+    # retry as long as `RetryableError` is reachable via the cause chain.
+    #
+    # @example
+    #   begin
+    #     backend.call
+    #   rescue BackendUnavailable => e
+    #     raise Anthropic::Errors::RetryableError, cause: e
+    #   end
+    class RetryableError < Anthropic::Errors::Error
+    end
+
     class ConversionError < Anthropic::Errors::Error
       # @return [StandardError, nil]
       def cause = @cause.nil? ? super : @cause

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

@@ -108,9 +108,9 @@ module Anthropic
         end
 
         # @api private
-        private def transform_request(request)
-          aws_auth_transform_request(request)
-        end
+        #
+        # @return [#call]
+        private def provider_middleware = method(:aws_auth_provider)
       end
     end
   end

data/lib/anthropic/helpers/aws_auth.rb

@@ -147,42 +147,52 @@ module Anthropic
         super
       end
 
-      # Applies workspace-id header and SigV4 signing to the request.
-      # Call from the including class's `transform_request`.
+      # The AWS provider middleware entry: applies the workspace-id header and
+      # SigV4 signing per attempt. Return from the including class's
+      # `provider_middleware`. Pure — requests are reused across retry
+      # attempts, so the incoming `req` is never mutated.
       #
-      # @param request [Hash{Symbol=>Object}]
-      # @return [Hash{Symbol=>Object}]
-      private def aws_auth_transform_request(request)
-        headers = request.fetch(:headers)
-
-        headers["anthropic-workspace-id"] = @workspace_id if @workspace_id
-
-        return request unless @use_sig_v4
-
-        # `Aws::Sigv4::Signer#sign_request` only accepts `String` / `IO` / `nil`
-        # bodies. Multipart and JSONL requests carry a lazy `Enumerable` body
-        # (see `Util.encode_content`), which the signer rejects. Materialize it
-        # to a `String` and replace the request body so the signed payload is
-        # exactly the bytes that go over the wire (the lazy enumerator can only
-        # be consumed once).
-        body = request[:body]
+      # @param req [Anthropic::APIRequest]
+      # @param nxt [#call]
+      # @return [Anthropic::APIResponse]
+      private def aws_auth_provider(req, nxt)
+        if @workspace_id
+          req = req.with(headers: {**req.headers, "anthropic-workspace-id" => @workspace_id})
+        end
+
+        # `follow_redirect` stripped `authorization` for a cross-origin hop —
+        # don't re-sign and leak credentials to the new origin.
+        req = sign_aws_request(req) if @use_sig_v4 && !req.metadata[:cross_origin_redirect]
+        nxt.call(req)
+      end
+
+      # SigV4 signs over the body bytes, so the canonical body is encoded here
+      # and the signed bytes ride down to the transport. `Aws::Sigv4::Signer`
+      # only accepts `String` / `IO` / `nil` bodies, and multipart/JSONL
+      # encodings are lazy single-consumer enumerables — materialize those into
+      # a `StringIO`, which the terminal's encoding passes through untouched,
+      # so the signed payload is exactly the bytes that go over the wire.
+      #
+      # @param req [Anthropic::APIRequest]
+      # @return [Anthropic::APIRequest]
+      private def sign_aws_request(req)
+        headers, encoded = Anthropic::Internal::Util.encode_content(req.headers, req.body)
         body =
-          case body
-          when nil, String, IO, StringIO
-            body
-          when Enumerable
-            materialized = body.to_a.join
-            request = {**request, body: materialized}
-            materialized
+          case encoded
+          in nil | StringIO | IO
+            encoded
+          in String
+            StringIO.new(encoded)
+          in Enumerable
+            StringIO.new(encoded.to_a.join)
           else
-            body.to_s
+            StringIO.new(encoded.to_s)
           end
 
-        sliced = {http_method: request.fetch(:method), url: request.fetch(:url), body: body}
-        signed = @signer.sign_request({**sliced, headers: headers})
+        signed = @signer.sign_request(http_method: req.method, url: req.url, body: body, headers: headers)
         headers = Anthropic::Internal::Util.normalized_headers(headers, signed.headers)
         headers.delete("connection")
-        {**request, headers: headers}
+        req.with(headers: headers, body: body)
       end
 
       # Resolves AWS credentials from explicit args, profile, env vars, or default chain.

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

@@ -4,6 +4,8 @@ module Anthropic
   module Helpers
     module Bedrock
       class Client < Anthropic::Client
+        include Anthropic::Helpers::AWSAuth
+
         DEFAULT_VERSION = "bedrock-2023-05-31"
 
         # @return [Anthropic::Resources::Messages]
@@ -53,6 +55,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 Bedrock URL rewrite and SigV4 signing happen inside the continuation, per
+        #   attempt.
+        #
         def initialize( # rubocop:disable Lint/MissingSuper
           aws_region: nil,
           base_url: nil,
@@ -64,7 +71,8 @@ module Anthropic
           aws_secret_key: nil,
           aws_session_token: nil,
           aws_profile: nil,
-          api_key: nil
+          api_key: nil,
+          middleware: nil
         )
           api_key ||= ENV["AWS_BEARER_TOKEN_BEDROCK"]
 
@@ -122,6 +130,10 @@ module Anthropic
           @auth_token = @signer ? nil : api_key
           @credentials = nil
           @token_cache = nil
+          # For AWSAuth#auth_headers: suppress key headers in SigV4 mode; in
+          # API-key mode fall through to the base bearer-token handling.
+          @use_sig_v4 = !@signer.nil?
+          @use_bearer_auth = false
 
           # Skip Anthropic::Client#initialize and bind BaseClient#initialize directly:
           # the parent's initializer runs OIDC/credential-provider resolution that does
@@ -132,7 +144,8 @@ module Anthropic
             max_retries: max_retries,
             initial_retry_delay: initial_retry_delay,
             max_retry_delay: max_retry_delay,
-            headers: {"anthropic-version" => "2023-06-01"}
+            headers: {"anthropic-version" => "2023-06-01"},
+            middleware: middleware
           )
 
           @messages = Anthropic::Resources::Messages.new(client: self)
@@ -178,36 +191,51 @@ module Anthropic
         #
         # @return [Hash{Symbol=>Object}]
         private def build_request(req, opts)
-          fit_req_to_bedrock_specs!(req)
-          req = super
-          body = req.fetch(:body)
-          req[:body] = StringIO.new(body.to_a.join) if body.is_a?(Enumerator)
-          req
+          validate_bedrock_request!(req)
+          super
         end
 
         # @api private
         #
-        # Very private API, do not use
-        #
-        # @param request [Hash{Symbol=>Object}] .
-        #
-        #   @option request [Symbol] :method
-        #
-        #   @option request [URI::Generic] :url
-        #
-        #   @option request [Hash{String=>String}] :headers
-        #
-        #   @option request [Object] :body
-        #
-        # @return [Hash{Symbol, Object}]
-        private def transform_request(request)
-          return request if @auth_token
+        # The Bedrock provider middleware: rewrites the canonical request into
+        # Bedrock's shape and SigV4-signs it. Appended innermost on every
+        # dispatch (below user middleware) and runs per attempt, so each retry
+        # or middleware-re-issued leg is re-adapted and re-signed for its own
+        # model and URL.
+        #
+        # @return [#call]
+        private def provider_middleware
+          lambda do |req, nxt|
+            req = adapt_request(req)
+            # `follow_redirect` stripped `authorization` for a cross-origin
+            # hop — don't re-sign and leak credentials to the new origin.
+            req = sign_aws_request(req) if @signer && !req.metadata[:cross_origin_redirect]
+            res = nxt.call(req)
+            # `invoke-with-response-stream` returns AWS event-stream framing,
+            # not SSE — transcode so `Util.decode_sse` and the streaming
+            # helpers work unchanged.
+            res = adapt_stream_response(res) if EventStream::AWS_CONTENT_TYPE.match?(res.headers["content-type"].to_s)
+            res
+          end
+        end
 
-          headers = request.fetch(:headers)
-          sliced = super.slice(:method, :url, :body).transform_keys(method: :http_method)
-          signed = @signer.sign_request({**sliced, headers: headers})
-          headers = Anthropic::Internal::Util.normalized_headers(headers, signed.headers)
-          {**request, headers: headers}
+        # @api private
+        #
+        # Rebuilds the response with the body transcoded from AWS event-stream
+        # framing to SSE bytes and the `content-type` rewritten so
+        # {Anthropic::Internal::Util.decode_content} dispatches to `decode_sse`.
+        #
+        # @param res [Anthropic::APIResponse]
+        # @return [Anthropic::APIResponse]
+        private def adapt_stream_response(res)
+          Anthropic::APIResponse.new(
+            status: res.status,
+            headers: res.headers.merge("content-type" => "text/event-stream"),
+            body: EventStream.to_sse(res.body),
+            raw: res.raw,
+            streaming: true,
+            request: res.request
+          )
         end
 
         # @param aws_region [String, nil]
@@ -243,35 +271,14 @@ module Anthropic
 
         # @private
         #
-        # Overrides request components for Bedrock-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
+        # Fail fast at request-build time on routes Bedrock does not support.
         #
-        #   @option request_components [Object, nil] :body
-        #
-        #   @option request_components [Symbol, nil] :unwrap
-        #
-        #   @option request_components [Class, nil] :page
-        #
-        #   @option request_components [Anthropic::Converter, Class, nil] :model
-        #
-        # @return [Hash{Symbol=>Object}]
-        #
-        private def fit_req_to_bedrock_specs!(request_components)
-          if (body = request_components[:body]).is_a?(Hash)
-            body[:anthropic_version] ||= DEFAULT_VERSION
-            body.transform_keys!("anthropic-beta": :anthropic_beta)
-          end
-
-          case request_components[:path]
+        # @param request_components [Hash{Symbol=>Object}]
+        # @return [void]
+        private def validate_bedrock_request!(request_components)
+          # Id-parameterized routes pass `path` as an Array whose first element
+          # is the format string (e.g. `["v1/messages/batches/%1$s", id]`).
+          case Array(request_components[:path]).first.to_s
           in %r{^v1/messages/batches}
             message = "The Batch API is not supported in Bedrock yet"
             raise NotImplementedError.new(message)
@@ -285,20 +292,45 @@ module Anthropic
             raise NotImplementedError.new(message)
           else
           end
+        end
 
-          if %w[
-            v1/complete
-            v1/messages
-            v1/messages?beta=true
-          ].include?(request_components[:path]) && request_components[:method] == :post && body.is_a?(Hash)
-            model = body.delete(:model)
-            model = URI.encode_www_form_component(model.to_s)
-            stream = body.delete(:stream) || false
-            request_components[:path] =
-              stream ? "model/#{model}/invoke-with-response-stream" : "model/#{model}/invoke"
-          end
+        # @api private
+        #
+        # Rewrites the canonical Anthropic request into Bedrock's shape — drops
+        # `:model`/`:stream` from the body and retargets the URL to
+        # `/model/{model}/invoke[-with-response-stream]`. Called from
+        # {#provider_middleware}, so user middleware sees the canonical
+        # request. Pure: the incoming request, its body, and its 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
+          return req unless body.is_a?(Hash)
+
+          body = body.transform_keys("anthropic-beta": :anthropic_beta)
+          body[:anthropic_version] ||= DEFAULT_VERSION
+
+          path = req.url.path.to_s
+          query = req.url.query
+          messages_route =
+            (path.end_with?("/v1/messages") && (query.nil? || query == "beta=true")) ||
+            (path.end_with?("/v1/complete") && query.nil?)
+
+          return req.with(body: body) unless req.method == :post && messages_route
+
+          model = URI.encode_www_form_component(body.delete(:model).to_s)
+          stream = body.delete(:stream) || false
+
+          url = req.url.dup
+          url.path = path.sub(
+            %r{v1/(?:messages|complete)\z},
+            stream ? "model/#{model}/invoke-with-response-stream" : "model/#{model}/invoke"
+          )
+          url.query = nil
 
-          request_components
+          req.with(body: body, url: url)
         end
       end
     end

data/lib/anthropic/helpers/bedrock/event_stream.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module Bedrock
+      # @api private
+      #
+      # Bedrock's `invoke-with-response-stream` returns
+      # `application/vnd.amazon.eventstream` (AWS binary event-stream framing),
+      # not SSE. The SDK's stream consumer parses SSE only — without this
+      # transcoder a Bedrock stream silently yields zero events. Each frame's
+      # payload is `{"bytes": "<base64>"}` wrapping a standard Anthropic event
+      # JSON; this re-emits those as `event:`/`data:` SSE bytes so the existing
+      # `Internal::Util.decode_sse` and the streaming helpers work unchanged.
+      module EventStream
+        AWS_CONTENT_TYPE = %r{^application/vnd\.amazon\.eventstream}
+
+        class << self
+          # @api private
+          #
+          # Transcodes the raw AWS event-stream byte chunks into SSE-formatted
+          # byte chunks. Incremental: each input chunk is fed to
+          # `Aws::EventStream::Decoder` and any complete frames are emitted
+          # immediately, so the stream is not buffered end-to-end.
+          #
+          # @param chunks [Enumerable<String>] raw response body chunks
+          # @return [Enumerable<String>] SSE-formatted body chunks
+          def to_sse(chunks)
+            # `aws-eventstream` ships with `aws-sdk-core`, which the Bedrock
+            # client already lazy-requires before any request can fire.
+            require("aws-eventstream")
+            decoder = Aws::EventStream::Decoder.new
+            Anthropic::Internal::Util.chain_fused(chunks) do |y|
+              chunks.each { |chunk| drain(decoder, chunk, y) }
+              drain(decoder, nil, y)
+            end
+          end
+
+          # @api private
+          #
+          # Feeds one chunk (or `nil` to flush) into the decoder and emits any
+          # complete frames as SSE bytes.
+          #
+          # @param decoder [Aws::EventStream::Decoder]
+          # @param chunk [String, nil]
+          # @param y [Enumerator::Yielder]
+          # @return [void]
+          def drain(decoder, chunk, y)
+            loop do
+              msg, eof = decoder.decode_chunk(chunk)
+              chunk = nil
+              break if msg.nil?
+              emit(msg, y)
+              break if eof
+            end
+          end
+
+          # @api private
+          #
+          # Emit one decoded AWS event-stream message as SSE bytes.
+          #
+          # `:message-type: event` frames carry a JSON payload
+          # `{"bytes": "<base64>"}` wrapping the Anthropic event; emit it as
+          # an `event:`/`data:` pair. `:message-type: exception` frames carry an
+          # error payload and a `:exception-type` header — re-emit as the same
+          # `event: error` / `data: {"type":"error",...}` SSE shape the API
+          # would have sent, so the stream consumer's existing error path fires.
+          #
+          # @param msg [Aws::EventStream::Message]
+          # @param y [Enumerator::Yielder]
+          # @return [void]
+          def emit(msg, y)
+            case msg.headers[":message-type"]&.value
+            in "event"
+              payload = JSON.parse(msg.payload.read, symbolize_names: true)
+              inner = Base64.decode64(payload.fetch(:bytes))
+              type = JSON.parse(inner, symbolize_names: true).fetch(:type)
+              y << "event: #{type}\ndata: #{inner}\n\n"
+            in "exception"
+              exc_type = msg.headers[":exception-type"]&.value
+              body = msg.payload.read
+              data = JSON.generate(type: "error", error: {type: exc_type, message: body})
+              y << "event: error\ndata: #{data}\n\n"
+            else
+              # Unknown message-type — drop. AWS may add prelude/metadata frames.
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/bedrock/mantle_client.rb

@@ -114,9 +114,9 @@ module Anthropic
         end
 
         # @api private
-        private def transform_request(request)
-          aws_auth_transform_request(request)
-        end
+        #
+        # @return [#call]
+        private def provider_middleware = method(:aws_auth_provider)
 
         # Restricted Beta service that only exposes messages. Other beta resources
         # (models, files, skills) are not supported on Bedrock Mantle.