anthropic 1.78.0 → 1.80.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 064db3cf4e22be64272a2aa28eb45829da4ddd01a3fdfec1cfc8bc0b6e9d0216
-  data.tar.gz: 1f65d4417898900499d402aff8b3225c2f2016a52984c25637800e4a8d4ec0c6
+  metadata.gz: 9e0c2457772d14d2f544f1e29c0257bb58470949ad75041d38a87337ef6588eb
+  data.tar.gz: f3a5fe15373f2aa6391d7ed66ed73687b46523d92fb359e4a9621df437183063
 SHA512:
-  metadata.gz: f6588afface6416906b56c266d0c088057aa93363b4cadb7e445ab7ec096c6bfb46006433109230ce001ce0fb4fb023cef2e294e35bb62c480c32f82d893c769
-  data.tar.gz: c6103754b6be3dfeb451995ab5d5a9b8aa68e0af8d7ad48306d06d8cf8c82d6100a152c9cb467600346ddd2446fbde3b9ef8e24a71350c1f4a4905e77b7f28e8
+  metadata.gz: 519eadd659c81d42cff516a695728b4bf93f69f6ad8fe7b931e765673421e427f6f8f00c35154c41ed4e5b211119150ce9949bc97cbe19d63893738ca15c2dbd
+  data.tar.gz: '088cd32906704806d4be30d6ddf5291d4a3565b1780bf9f6ba87b1a2bf26fa501a2d158e7743d5afe2a4adda9c8762d94acbe6df91a077db75319d64ce065fc5'

data/CHANGELOG.md

@@ -1,5 +1,62 @@
 # Changelog
 
+## [1.80.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.79.0...v1.80.0) (2026-10-15)
+
+### Features
+
+* **api:** add between_tools to thinking types in model capabilities
+* **api:** add the speed parameter and usage.speed to Messages
+* **api:** return a Console organization's usage-tier spend cap as a read-only spend limit
+
+
+### Chores
+
+* **ci:** speed up breaking change detection
+* **docs:** describe headers on Managed Agents and telemetry endpoints
+* **tests:** cover trace context propagation and failing telemetry
+
+
+### Documentation
+
+* **api:** note that some models need a beta header to use speed
+
+## [1.79.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.78.0...v1.79.0) (2026-10-14)
+
+### Features
+
+* **api:** add execution_identity to Managed Agents agents
+* **api:** add organization_type_not_supported error to spend limit lists
+* **api:** add telemetry destination test endpoint
+* **api:** add telemetry destinations to the Admin API
+* **client:** add native support for OpenTelemetry tracing
+
+  If your app registers a global tracer provider, the SDK will create spans with it after upgrading, and they'll be exported with the rest of your traces. Requests will also get trace context headers from the global propagator. To disable, pass `open_telemetry: false` to the client or set `ANTHROPIC_OPEN_TELEMETRY=false`. Learn more in the [documentation](https://platform.claude.com/docs/en/manage-claude/opentelemetry/sdk).
+
+
+### Bug Fixes
+
+* **api:** rename telemetry destination test response model
+* **client:** ignore OpenTelemetry env vars when the option is set
+* **client:** keep the discriminator when a union's .new builds a variant
+* **streaming:** keep every field of a tool use block when attaching its parsed input
+* **streaming:** pass events of an unknown type through the message stream helper untouched
+* **tools:** name the toolset on the tool runner's result for a toolset member's call
+
+
+### Chores
+
+* **docs:** correct prefill, thinking, fallback and model descriptions
+* **docs:** document the scope required to assign the managed role
+* **docs:** update model examples
+* include the license files in the published packages
+* **internal:** narrow the tripwire test rule in the contributor guides
+
+
+### Documentation
+
+* **api:** clarify when custom tool results can be sent
+* **api:** say is_enabled is always true for user spend limits
+
 ## [1.78.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.77.1...v1.78.0) (2026-10-09)
 
 ### Features

data/LICENSE

@@ -0,0 +1,8 @@
+Copyright 2023 Anthropic, PBC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README.md

@@ -15,7 +15,7 @@ Add to your application's Gemfile:
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "anthropic", "~> 1.78.0"
+gem "anthropic", "~> 1.80.0"
 ```
 
 <!-- x-release-please-end -->
@@ -44,6 +44,47 @@ puts(message.content)
 
 Ruby 3.2.0+
 
+## OpenTelemetry
+
+Spans are on by default.
+Register a tracer provider with OpenTelemetry, for example with `OpenTelemetry::SDK.configure`, and every client reports each API call as a span.
+No client option is needed.
+Each request also carries the trace context in the headers that the registered propagator writes, such as `traceparent`, with or without a tracer provider.
+
+The `open_telemetry` client option changes the default:
+
+- `open_telemetry: {tracer_provider: provider}` uses `provider` instead of the registered tracer provider.
+- `open_telemetry: {propagation: false}` sends no trace context headers, such as `traceparent` and `baggage`, with the client's requests.
+  It is for an application whose HTTP client instrumentation already sends them, so that a request does not carry them twice. The spans are unaffected.
+- `open_telemetry: false` turns the spans and the trace context headers off. It is short for `{traces: false}`, which is short for `{traces: {enabled: false}}`.
+- `open_telemetry: {traces: {content_mode: :content}}` adds the messages, stop sequences, and tool calls to the spans.
+  It also adds `url.query` and `url.full` to the span of a request whose query has an `email`, `path_prefix` or `expected_content_sha256` parameter, which has neither otherwise.
+- `open_telemetry: {traces: {max_content_bytes: 65_536}}` sets the most bytes of content that one span holds, in place of 0.75 MB.
+  A span whose content is cut to fit has `anthropic.content.truncated`.
+
+`open_telemetry: true` is short for `{traces: true}`, and `traces: true` is short for `traces: {enabled: true}`.
+With `enabled: false`, the other keys of `traces` are unused.
+What the option leaves unset has its default.
+
+A client that is given no `open_telemetry` option reads the environment when it is made: `ANTHROPIC_OPEN_TELEMETRY=false` turns its spans and the trace context headers off, `ANTHROPIC_OPEN_TELEMETRY_PROPAGATION=false` turns only the headers off, `ANTHROPIC_OPEN_TELEMETRY_TRACES_CONTENT_MODE=content` adds the content, and `ANTHROPIC_OPEN_TELEMETRY_TRACES_MAX_CONTENT_BYTES=65536` sets the most bytes.
+A client that is given the option, even `true` or `{}`, reads none of these variables: `open_telemetry: true` turns the spans on whatever `ANTHROPIC_OPEN_TELEMETRY` says.
+
+The keys of the option, and of its `traces`, can be Symbols or Strings, and a key that the option does not have raises `ArgumentError`.
+So does a `propagation` other than `true` or `false`, a `content_mode` other than `:metadata_only` or `:content`, and a `max_content_bytes` that is not an Integer of 1 or more.
+An environment variable with such a value is ignored.
+
+One request option sets `gen_ai.conversation.id` on the span of a call:
+
+```ruby
+anthropic.messages.create(**params, request_options: {open_telemetry: {conversation_id: id}})
+```
+
+`conversation_id` is the only key of the request option, and any other key raises `ArgumentError`: the tracer provider, `propagation` and the `traces` settings belong to the client.
+Without it, the span of a request to a Session thread, such as `beta.sessions.threads.retrieve`, has the thread's ID as its `gen_ai.conversation.id`.
+
+In the content mode, the content of a streamed response comes from the message that `messages.stream` accumulates.
+The span of a `messages.stream_raw` call has the request's content only.
+
 ## Contributing
 
 See [CONTRIBUTING.md](./CONTRIBUTING.md).

data/lib/anthropic/client.rb

@@ -190,6 +190,36 @@ module Anthropic
     # @param timeout [Float, nil] Request timeout in seconds. Defaults to
     # `Anthropic::Client::DEFAULT_TIMEOUT_IN_SECONDS` when `nil`.
     #
+    # @param open_telemetry [Hash{Symbol=>Object}, Boolean, nil] OpenTelemetry tracing of this client's API calls. Each call emits a span when
+    # the application has registered a tracer provider with the OpenTelemetry API.
+    # `true` and `false` are short for `{traces: true}` and `{traces: false}`. Keys
+    # can be Strings, and an unknown key raises `ArgumentError`. A client that is
+    # given no option reads `ENV["ANTHROPIC_OPEN_TELEMETRY"]`, where `false` is
+    # `open_telemetry: false`, `ENV["ANTHROPIC_OPEN_TELEMETRY_PROPAGATION"]`, where
+    # `false` is `propagation: false`,
+    # `ENV["ANTHROPIC_OPEN_TELEMETRY_TRACES_CONTENT_MODE"]` and
+    # `ENV["ANTHROPIC_OPEN_TELEMETRY_TRACES_MAX_CONTENT_BYTES"]`. A client that is
+    # given the option, even `true` or `{}`, reads none of them.
+    #
+    #   @option open_telemetry [#tracer] :tracer_provider Used in place of the registered tracer provider.
+    #
+    #   @option open_telemetry [Boolean] :propagation `false` sends no trace context headers, such as `traceparent`, with this
+    #   client's requests, for an application whose HTTP client instrumentation already
+    #   sends them, so that a request does not carry them twice. The spans are
+    #   unaffected. Defaults to `true`.
+    #
+    #   @option open_telemetry [Hash{Symbol=>Object}, Boolean] :traces The settings of the spans. `true` and `false` are short for `{enabled: true}`
+    #   and `{enabled: false}`. Its keys:
+    #
+    #   - `:enabled` (Boolean): `false` disables the spans, and the other keys are then
+    #     unused. Defaults to `true`.
+    #   - `:content_mode` (Symbol, String): `:content` adds the content of requests and
+    #     responses to the spans, and `:metadata_only` does not. Defaults to
+    #     `:metadata_only`.
+    #   - `:max_content_bytes` (Integer): the most bytes of content that one span holds,
+    #     1 or more. Content over the bound is cut, and the span then has
+    #     `anthropic.content.truncated`. Defaults to 0.75 MB.
+    #
     # @param initial_retry_delay [Float]
     #
     # @param max_retry_delay [Float]
@@ -207,6 +237,7 @@ module Anthropic
       proxy: nil,
       max_retries: self.class::DEFAULT_MAX_RETRIES,
       timeout: nil,
+      open_telemetry: nil,
       initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
       max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY,
       middleware: nil
@@ -298,6 +329,7 @@ module Anthropic
         base_url: base_url,
         proxy: proxy,
         timeout: timeout,
+        open_telemetry: open_telemetry,
         max_retries: max_retries,
         initial_retry_delay: initial_retry_delay,
         max_retry_delay: max_retry_delay,

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

@@ -54,6 +54,9 @@ module Anthropic
         #
         # @param max_retry_delay [Float]
         #
+        # @param open_telemetry [Hash{Symbol=>Object}, Boolean, nil] OpenTelemetry tracing of this
+        #   client's API calls. See {Anthropic::Client#initialize}.
+        #
         def initialize(
           api_key: nil,
           aws_access_key: nil,
@@ -67,7 +70,8 @@ module Anthropic
           max_retries: self.class::DEFAULT_MAX_RETRIES,
           timeout: nil,
           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,
+          open_telemetry: nil
         )
           effective_api_key, resolved_base_url = setup_aws_auth(
             api_key: api_key,
@@ -96,10 +100,16 @@ module Anthropic
             timeout: timeout,
             max_retries: max_retries,
             initial_retry_delay: initial_retry_delay,
-            max_retry_delay: max_retry_delay
+            max_retry_delay: max_retry_delay,
+            open_telemetry: open_telemetry
           )
         end
 
+        # @api private
+        #
+        # @return [String]
+        private def open_telemetry_scope = "#{super}.aws"
+
         # @api private
         #
         # @return [#call]

data/lib/anthropic/helpers/aws_auth.rb

@@ -185,6 +185,10 @@ module Anthropic
       # a `StringIO`, which the terminal's encoding passes through untouched,
       # so the signed payload is exactly the bytes that go over the wire.
       #
+      # The headers that carry a trace context are sent but not signed: an HTTP
+      # instrumentation may replace them with the context of its own span after
+      # this, which would invalidate a signature that covered them.
+      #
       # @param req [Anthropic::APIRequest]
       # @return [Anthropic::APIRequest]
       private def sign_aws_request(req)
@@ -201,7 +205,10 @@ module Anthropic
             StringIO.new(encoded.to_s)
           end
 
-        signed = @signer.sign_request(http_method: req.method, url: req.url, body: body, headers: headers)
+        # The propagator is read per request: the application may register it after it makes the client.
+        unsigned = %w[traceparent tracestate baggage] | Anthropic::Internal::Tracing.trace_header_names(nil)
+        signable = headers.reject { |name, _| unsigned.include?(name.to_s.downcase) }
+        signed = @signer.sign_request(http_method: req.method, url: req.url, body: body, headers: signable)
         headers = Anthropic::Internal::Util.normalized_headers(headers, signed.headers)
         headers.delete("connection")
         req.with(headers: headers, body: body)

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

@@ -61,6 +61,9 @@ module Anthropic
         #   the Bedrock URL rewrite and SigV4 signing happen inside the continuation, per
         #   attempt.
         #
+        # @param open_telemetry [Hash{Symbol=>Object}, Boolean, nil] OpenTelemetry tracing of this
+        #   client's API calls. See {Anthropic::Client#initialize}.
+        #
         def initialize(
           aws_region: nil,
           base_url: nil,
@@ -73,7 +76,8 @@ module Anthropic
           aws_session_token: nil,
           aws_profile: nil,
           api_key: nil,
-          middleware: nil
+          middleware: nil,
+          open_telemetry: nil
         )
           api_key ||= ENV["AWS_BEARER_TOKEN_BEDROCK"]
 
@@ -140,7 +144,8 @@ module Anthropic
             max_retries: max_retries,
             initial_retry_delay: initial_retry_delay,
             max_retry_delay: max_retry_delay,
-            middleware: middleware
+            middleware: middleware,
+            open_telemetry: open_telemetry
           )
         end
 
@@ -206,6 +211,18 @@ module Anthropic
           super
         end
 
+        # @api private
+        #
+        # @return [Hash{String=>String}]
+        def open_telemetry_attributes
+          {**super, Anthropic::Internal::Tracing::GEN_AI_PROVIDER_NAME => "aws.bedrock"}
+        end
+
+        # @api private
+        #
+        # @return [String]
+        private def open_telemetry_scope = "#{super}.bedrock"
+
         # @api private
         #
         # The Bedrock provider middleware: rewrites the canonical request into

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

@@ -58,6 +58,9 @@ module Anthropic
         #
         # @param max_retry_delay [Float]
         #
+        # @param open_telemetry [Hash{Symbol=>Object}, Boolean, nil] OpenTelemetry tracing of this
+        #   client's API calls. See {Anthropic::Client#initialize}.
+        #
         def initialize(
           api_key: nil,
           aws_access_key: nil,
@@ -70,7 +73,8 @@ module Anthropic
           max_retries: self.class::DEFAULT_MAX_RETRIES,
           timeout: nil,
           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,
+          open_telemetry: nil
         )
           effective_api_key, resolved_base_url = setup_aws_auth(
             api_key: api_key,
@@ -94,7 +98,8 @@ module Anthropic
             max_retries: max_retries,
             timeout: timeout,
             initial_retry_delay: initial_retry_delay,
-            max_retry_delay: max_retry_delay
+            max_retry_delay: max_retry_delay,
+            open_telemetry: open_telemetry
           )
 
           # Only initialize supported resources
@@ -126,6 +131,18 @@ module Anthropic
                 "Skills are not supported on Bedrock Mantle. Only Messages (/v1/messages) is supported."
         end
 
+        # @api private
+        #
+        # @return [Hash{String=>String}]
+        def open_telemetry_attributes
+          {**super, Anthropic::Internal::Tracing::GEN_AI_PROVIDER_NAME => "aws.bedrock"}
+        end
+
+        # @api private
+        #
+        # @return [String]
+        private def open_telemetry_scope = "#{super}.bedrock"
+
         # @api private
         #
         # @return [#call]

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

@@ -87,6 +87,9 @@ module Anthropic
         #   is applied per attempt, after user middleware.
         #
         # @raise [ArgumentError]
+        #
+        # @param open_telemetry [Hash{Symbol=>Object}, Boolean, nil] OpenTelemetry tracing of this
+        #   client's API calls. See {Anthropic::Client#initialize}.
         def initialize(
           project: ENV["ANTHROPIC_GOOGLE_CLOUD_PROJECT"] || ENV["GOOGLE_CLOUD_PROJECT"],
           location: ENV["ANTHROPIC_GOOGLE_CLOUD_LOCATION"] || "global",
@@ -99,7 +102,8 @@ module Anthropic
           timeout: nil,
           initial_retry_delay: self.class::DEFAULT_INITIAL_RETRY_DELAY,
           max_retry_delay: self.class::DEFAULT_MAX_RETRY_DELAY,
-          middleware: nil
+          middleware: nil,
+          open_telemetry: nil
         )
           if skip_auth && (token_provider || google_credentials)
             raise ArgumentError.new(
@@ -151,7 +155,8 @@ module Anthropic
             max_retries: max_retries,
             initial_retry_delay: initial_retry_delay,
             max_retry_delay: max_retry_delay,
-            middleware: middleware
+            middleware: middleware,
+            open_telemetry: open_telemetry
           )
         end
 
@@ -180,6 +185,11 @@ module Anthropic
         # @return [Hash{String=>String}]
         private def auth_headers = {}
 
+        # @api private
+        #
+        # @return [String]
+        private def open_telemetry_scope = "#{super}.google_cloud"
+
         # @api private
         #
         # The Google Cloud provider middleware: applies the Google OAuth

data/lib/anthropic/helpers/refusal_fallback.rb

@@ -38,10 +38,11 @@ module Anthropic
   # — and the fallback's events are spliced onto the still-open stream, so the
   # client sees one continuous message: a `fallback` content block at each
   # model boundary, monotonic block indices, and per-hop `usage.iterations` on
-  # the final `message_delta`. Only `model` is honored from each entry on this
-  # path: the credit token is redeemable only against the refused request's
-  # body, so the other per-entry overrides would be rejected. A
-  # `between_tools` thinking config is always sent as `disabled` on this path.
+  # the final `message_delta`. Only `model` and `speed` are honored from each
+  # entry on this path. The other per-entry overrides are ignored, because the
+  # credit token is tied to the refused request's body. A `speed` value replaces
+  # the request's, and `speed: nil` omits it. A `between_tools` thinking config
+  # is always sent as `disabled` on this path.
   #
   # Credit tokens are sent in the object form with `mode: :best_effort`, so a
   # failing redemption never rejects the retry — it proceeds at normal price
@@ -49,6 +50,10 @@ module Anthropic
   # beta this requires is sent by default on every request the middleware
   # handles; the `betas:` option controls this.
   #
+  # A `speed: "fast"` request that falls back to an entry with no `speed`, and
+  # is rejected with a 429 or 529, is retried once on that entry without
+  # `speed`. Set `speed: "fast"` on the entry to keep it fast-only.
+  #
   # To keep later requests on the model that accepted, pass a
   # {BetaFallbackState} via the `fallback_state` request option; requests
   # sharing that state start directly at the pinned fallback.
@@ -72,7 +77,7 @@ module Anthropic
     #   …) patch the original request body for that hop — a value overrides
     #   the param, an explicit `nil` unsets it, an absent key keeps the
     #   original value (an absent `thinking:` sends `between_tools` as
-    #   `disabled`).
+    #   `disabled`). On the streaming path only `speed:` patches it.
     # @param betas [Array<String>] betas added to the `anthropic-beta` header
     #   of every `/v1/messages` request this middleware handles. Defaults to
     #   `["fallback-credit-2026-07-01"]`; pass `[]` to send none.
@@ -129,24 +134,24 @@ module Anthropic
       end
 
       streaming = req.streaming?
+      entry = @fallbacks.fetch(start_index) unless start_index == -1
       initial_body =
-        if start_index == -1
+        if entry.nil?
           body
         elsif streaming
-          # Only `model` is honored on the streaming path so the credit token
-          # — redeemable only against the refused request's body — stays valid
-          # for the spliced hops.
-          degrade_between_tools(body.merge(model: @fallbacks.fetch(start_index).fetch(:model)))
+          # Only `model` and `speed` are honored on the streaming path: the credit
+          # token is tied to the refused request's body.
+          degrade_between_tools(patch(body, entry.slice(:speed)).merge(model: entry.fetch(:model)))
         else
-          apply_fallback(body, @fallbacks.fetch(start_index))
+          apply_fallback(body, entry)
         end
-      res = nxt.call(req.with(body: initial_body))
+      res = entry ? send_hop(req, nxt, entry, initial_body).first : nxt.call(req.with(body: initial_body))
       return res unless res.status < 300
 
       if streaming
         first_hop = start_index + 1
         return res unless first_hop < @fallbacks.length
-        return splice_fallback_stream(req, res, nxt, body, first_hop, pin)
+        return splice_fallback_stream(req, res, nxt, initial_body, first_hop, pin)
       end
 
       handle_non_streaming(req, res, nxt, body, start_index, pin)
@@ -276,6 +281,25 @@ module Anthropic
       {token: token, mode: Anthropic::Models::Beta::BetaFallbackCreditTokenParam::Mode::BEST_EFFORT}
     end
 
+    # Send a request built from `entry`. One that is fast only because the
+    # original request was, and is rejected with a 429 or 529, is resent once
+    # without `speed`, and that response stands in for the first.
+    #
+    # @param req [Anthropic::APIRequest]
+    # @param nxt [#call]
+    # @param entry [Hash{Symbol=>Object}]
+    # @param hop_body [Hash{Symbol=>Object}]
+    # @return [Array(Anthropic::APIResponse, Boolean)] the response, and whether
+    #   it answers the resend.
+    def send_hop(req, nxt, entry, hop_body)
+      res = nxt.call(req.with(body: hop_body))
+      return [res, false] unless [429, 529].include?(res.status)
+      return [res, false] if entry.key?(:speed) || hop_body[:speed].to_s != "fast"
+
+      Anthropic::Internal::Util.close_fused!(res.body)
+      [nxt.call(req.with(body: hop_body.except(:speed))), true]
+    end
+
     # --- non-streaming ------------------------------------------------------
 
     # @param req [Anthropic::APIRequest]
@@ -303,7 +327,7 @@ module Anthropic
         hop_body = hop_body.merge(fallback_credit_token: credit_token_param(token)) if token
 
         begin
-          hop_res = nxt.call(req.with(body: hop_body))
+          hop_res = send_hop(req, nxt, entry, hop_body).first
         rescue StandardError
           hop_res = nil
         end
@@ -359,7 +383,7 @@ module Anthropic
     # @param req [Anthropic::APIRequest]
     # @param res [Anthropic::APIResponse]
     # @param nxt [#call]
-    # @param body [Hash{Symbol=>Object}] the stripped request body
+    # @param body [Hash{Symbol=>Object}] the body built for stream A
     # @param first_hop [Integer]
     # @param pin [Proc]
     # @return [Anthropic::APIResponse]
@@ -399,10 +423,12 @@ module Anthropic
       iterations = [iteration_usage("message", a[:model] || "", a.dig(:refused, :usage))]
 
       (first_hop...@fallbacks.length).each do |hop|
-        model = @fallbacks.fetch(hop).fetch(:model).to_s
+        entry = @fallbacks.fetch(hop)
+        model = entry.fetch(:model).to_s
         has_next = hop + 1 < @fallbacks.length
 
-        res_b, sent, failed = issue_hop(req, nxt, degrade_between_tools(body), model, token, base, partial)
+        hop_body = degrade_between_tools(patch(body, entry.slice(:speed)))
+        res_b, sent, failed = issue_hop(req, nxt, hop_body, entry, token, base, partial)
 
         if failed
           next if has_next
@@ -465,15 +491,19 @@ module Anthropic
       end
     end
 
-    # Issue one fallback hop with a single 400-on-prefill retry.
+    # Issue one fallback hop with a single 400-on-prefill retry, which stays
+    # without `speed` once the hop has been resent without it.
     #
     # @return [Array(Anthropic::APIResponse, Array<Hash>, false), Array(nil, Array<Hash>, true)]
     #   the response, the continuation actually sent (`base + partial`, or
     #   `base` if the prefill was dropped on retry), and whether the hop failed.
-    def issue_hop(req, nxt, body, model, token, base, partial)
+    def issue_hop(req, nxt, body, entry, token, base, partial)
       continuation = base + partial
       2.times do |attempt|
-        hop_body = body.merge(model: model, fallback_credit_token: credit_token_param(token))
+        hop_body = body.merge(
+          model: entry.fetch(:model).to_s,
+          fallback_credit_token: credit_token_param(token)
+        )
         unless continuation.empty?
           hop_body = hop_body.merge(
             messages: body.fetch(:messages) + [{role: :assistant, content: continuation}]
@@ -481,10 +511,11 @@ module Anthropic
         end
 
         begin
-          res = nxt.call(req.with(body: hop_body))
+          res, resent = send_hop(req, nxt, entry, hop_body)
         rescue StandardError
           return [nil, continuation, true]
         end
+        body = body.except(:speed) if resent
         return [res, continuation, false] if res.status < 300
 
         if attempt.zero? && res.status == 400 && !partial.empty?

data/lib/anthropic/helpers/streaming/message_stream.rb

@@ -22,12 +22,20 @@ module Anthropic
         #
         # @return [Enumerable<generic<Elem>>]
         private def iterator
-          @iterator ||= Anthropic::Internal::Util.chain_fused(@stream) do |y|
+          # Closing this stream closes the raw stream, which ends the request.
+          @iterator ||= Anthropic::Internal::Util.chain_fused(@raw_stream.to_enum) do |y|
             @raw_stream.each do |raw_event|
-              @accumated_message_snapshot = accumulate_event(
-                event: raw_event,
-                current_snapshot: @accumated_message_snapshot
-              )
+              # An event of a type this version doesn't know arrives as the closest known class, with
+              # `type` left as a String.
+              unless raw_event.type.is_a?(Symbol)
+                y << raw_event
+                next
+              end
+
+              @accumated_message_snapshot =
+                Anthropic::Helpers::Tracing.accumulate_streamed_message(@raw_stream) do
+                  accumulate_event(event: raw_event, current_snapshot: @accumated_message_snapshot)
+                end
               events_to_yield = build_events(event: raw_event, message_snapshot: @accumated_message_snapshot)
               events_to_yield.each(&y)
             end
@@ -96,18 +104,11 @@ module Anthropic
             raise ArgumentError.new(message)
           end
 
-          if current_snapshot.nil?
-            return event.message if event.type == :message_start
-
-            message = "Unexpected event order, got \"#{event.type}\" before \":message_start\""
-            raise RuntimeError.new(message)
-          end
-
           case event
           in Anthropic::Models::RawMessageStartEvent
-            # `coerce` returns `event.message` itself when it is already a Message (as does the
-            # first-event return above), so the snapshot *is* the message_start event's message
-            # and the branches below mutate it in place rather than an isolated copy.
+            # `coerce` returns `event.message` itself when it is already a Message, so the snapshot *is*
+            # the message_start event's message and the branches below mutate it in place rather than
+            # an isolated copy.
             return Anthropic::Internal::Type::Converter.coerce(Anthropic::Models::Message, event.message)
           in Anthropic::Models::BetaRawMessageStartEvent
             return Anthropic::Internal::Type::Converter.coerce(Anthropic::Models::BetaMessage, event.message)
@@ -316,6 +317,7 @@ module Anthropic
         # @api private
         #
         # Parse tool use blocks and text blocks with structured output in the message.
+        # A block is kept as it arrived, with only `parsed` added to it.
         #
         # @param message [Anthropic::Models::Message] The message to parse
         #
@@ -324,7 +326,7 @@ module Anthropic
           return message unless message&.content
 
           # rubocop:disable Metrics/BlockLength
-          message.content.each_with_index do |content, index|
+          message.content.each do |content|
             case content.type
             when :tool_use
               next unless (tool = @tools[content.name])
@@ -342,20 +344,7 @@ module Anthropic
                   e
                 end
 
-              cls =
-                case content
-                in Anthropic::ContentBlock
-                  Anthropic::Models::ToolUseBlock
-                else
-                  Anthropic::Models::BetaToolUseBlock
-                end
-              message.content[index] = cls.new(
-                id: content.id,
-                input: content.input,
-                name: content.name,
-                type: content.type,
-                parsed: parsed
-              )
+              content.parsed = parsed
             when :text
               next unless (model = @models.first&.last)
 
@@ -367,19 +356,7 @@ module Anthropic
                   {error: e.message}
                 end
 
-              cls =
-                case content
-                in Anthropic::ContentBlock
-                  Anthropic::Models::TextBlock
-                else
-                  Anthropic::Models::BetaTextBlock
-                end
-              message.content[index] = cls.new(
-                citations: content.citations,
-                text: content.text,
-                type: content.type,
-                parsed: parsed
-              )
+              content.parsed = parsed
             end
           end
           # rubocop:enable Metrics/BlockLength