anthropic 1.23.0 → 1.24.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5e7f34d5d181c452996ffe49befe4bea248cd67a952eb8853cabf5d0ced185ef
-  data.tar.gz: 6945acf587c974e918efdbac79a408b1e3dfc787925037ca938f90cb4b601743
+  metadata.gz: d8e994ed4ea60cbaf7aee144bcabab2da5406df0c604d5dab2687b8ba226ec47
+  data.tar.gz: 963a20b35842c61557dc0cd60a1afbf00116653cfa120f1291fc840c4562933b
 SHA512:
-  metadata.gz: f1f562c0d5bfa17193f8d4952cdf91b2ed68777f87d7a72ed4ce993a457acbdcee4bb9256329a97b4a49513216c077e404b93b06f58241344174a52d956dd84f
-  data.tar.gz: 8e28e293264fa8cf7cd2611211a98f99e524df4485f9d16455b0a6a53e7a6cab3423859c3168b6ab1ea6b18ee071f1761880592c37d4944aa99feb9ea22ec012
+  metadata.gz: 2df975c4dde315c09393d07959e77315ce1bf725e0955c56085c0c0f444207b988e07ee7e2a78a688fb50df1781448f2c9c6a6ec00ea40a42ccb3597aa615308
+  data.tar.gz: 466afa0cd510de890dcd18e075a8ebb378877ce10636184eda10bc185c11ce4d4095d81cc778aa314b07011d8f476ce62ca30694993c60826992ee5f0a135882

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 # Changelog
 
+## 1.24.0 (2026-03-16)
+
+Full Changelog: [v1.23.0...v1.24.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.23.0...v1.24.0)
+
+### Features
+
+* **api:** chore(config): clean up model enum list ([#31](https://github.com/anthropics/anthropic-sdk-ruby/issues/31)) ([8549634](https://github.com/anthropics/anthropic-sdk-ruby/commit/8549634385a81b071ac05f02c74a5d5d36ea98fa))
+* **api:** GA thinking-display-setting ([227f58a](https://github.com/anthropics/anthropic-sdk-ruby/commit/227f58acb9944be56d21ea9fe46af8b5d9e1c891))
+* **tests:** update mock server ([2312be3](https://github.com/anthropics/anthropic-sdk-ruby/commit/2312be3b2f0f9846d70fa5ee7264463452349e21))
+
+
+### Bug Fixes
+
+* **client:** update model references from claude-3-opus-20240229 to claude-opus-4-6 ([#831](https://github.com/anthropics/anthropic-sdk-ruby/issues/831)) ([0c56fe4](https://github.com/anthropics/anthropic-sdk-ruby/commit/0c56fe4e7d279b9228613982f97c4836d7267a43))
+* properly mock time in ruby ci tests ([a56c1fe](https://github.com/anthropics/anthropic-sdk-ruby/commit/a56c1fe2bb14d1238855c41c791d69b44904f691))
+
+
+### Chores
+
+* **internal:** codegen related update ([0cf7f7e](https://github.com/anthropics/anthropic-sdk-ruby/commit/0cf7f7e485248290f54a83e907fb9623585c15f5))
+* **internal:** codegen related update ([a2218e5](https://github.com/anthropics/anthropic-sdk-ruby/commit/a2218e53a85e7544bedc8b55c8e5a9d4ef4dd35c))
+* **internal:** codegen related update ([b77acd4](https://github.com/anthropics/anthropic-sdk-ruby/commit/b77acd489387413cda40134f6a9463dfe850c71d))
+* **tests:** unskip tests that are now supported in steady ([9fe434d](https://github.com/anthropics/anthropic-sdk-ruby/commit/9fe434d6afdc979897754e5127c56f541bb6eb76))
+
+
+### Documentation
+
+* streamline README, centralize documentation at docs.anthropic.com ([396688b](https://github.com/anthropics/anthropic-sdk-ruby/commit/396688b823bf08690714c4f42160b4aa20d86880))
+
 ## 1.23.0 (2026-02-19)
 
 Full Changelog: [v1.22.0...v1.23.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.22.0...v1.23.0)

data/README.md

@@ -1,32 +1,26 @@
-# Anthropic Ruby API library
+# Claude SDK for Ruby
 
-The Anthropic Ruby library provides convenient access to the Anthropic REST API from any Ruby 3.2.0+ application. It ships with comprehensive types & docstrings in Yard, RBS, and RBI – [see below](https://github.com/anthropics/anthropic-sdk-ruby#Sorbet) for usage with Sorbet. The standard library's `net/http` is used as the HTTP transport, with connection pooling via the `connection_pool` gem.
+[![Gem Version](https://img.shields.io/gem/v/anthropic.svg)](https://rubygems.org/gems/anthropic)
 
-## Documentation
+The Claude SDK for Ruby provides access to the [Claude API](https://docs.anthropic.com/en/api/) from Ruby applications.
 
-Documentation for releases of this gem can be found [on RubyDoc](https://gemdocs.org/gems/anthropic).
+## Documentation
 
-The REST API documentation can be found on [docs.anthropic.com](https://docs.anthropic.com/claude/reference/).
+Full documentation is available at **[platform.claude.com/docs/en/api/sdks/ruby](https://platform.claude.com/docs/en/api/sdks/ruby)**.
 
 ## Installation
 
-To use this gem, install via Bundler by adding the following to your application's `Gemfile`:
+Add to your application's Gemfile:
 
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "anthropic", "~> 1.23.0"
+gem "anthropic", "~> 1.24.0"
 ```
 
 <!-- x-release-please-end -->
 
-## Feedback
-
-If you have recommendations, notice bugs, find things confusing, or anything else, create a github issue. Don't be shy -- we're very open to hearing any thoughts and musings you have!
-
-Feel free to make an issue for more substantial issues. For smaller issues or stream-of-thought, you can use the [pinned issue here](https://github.com/anthropics/anthropic-sdk-ruby/issues/85).
-
-## Usage
+## Getting started
 
 ```ruby
 require "bundler/setup"
@@ -39,439 +33,24 @@ anthropic = Anthropic::Client.new(
 message = anthropic.messages.create(
   max_tokens: 1024,
   messages: [{role: "user", content: "Hello, Claude"}],
-  model: "claude-sonnet-4-5-20250929"
+  model: "claude-opus-4-6"
 )
 
 puts(message.content)
 ```
 
-### Streaming
-
-We provide support for streaming responses using Server-Sent Events (SSE).
-
-```ruby
-stream = anthropic.messages.stream(
-  max_tokens: 1024,
-  messages: [{role: "user", content: "Hello, Claude"}],
-  model: "claude-sonnet-4-5-20250929"
-)
-
-stream.each do |message|
-  puts(message.type)
-end
-```
-
-### Streaming Helpers
-
-This library provides several conveniences for streaming messages, for example:
-
-```ruby
-stream = anthropic.messages.stream(
-  max_tokens: 1024,
-  messages: [{role: :user, content: "Say hello there!"}],
-  model: :"claude-sonnet-4-5-20250929"
-)
-
-stream.text.each do |text|
-  print(text)
-end
-```
-
-Streaming with `anthropic.messages.stream(...)` exposes [various helpers for your convenience](helpers.md) including accumulation & SDK-specific events.
-
-### Input Schema & Tool Calling
-
-We have helper mechanisms to define structured data classes for tools and let Claude automatically execute them.
-
-Please refer to [helpers.md](helpers.md) for more detailed usage information.
-
-```ruby
-class CalculatorInput < Anthropic::BaseModel
-  required :lhs, Float
-  required :rhs, Float
-  required :operator, Anthropic::InputSchema::EnumOf[:+, :-, :*, :/]
-end
-
-class Calculator < Anthropic::BaseTool
-  input_schema CalculatorInput
-
-  def call(expr)
-    expr.lhs.public_send(expr.operator, expr.rhs)
-  end
-end
-
-# Automatically handles tool execution loop
-client.beta.messages.tool_runner(
-  model: "claude-sonnet-4-5-20250929",
-  max_tokens: 1024,
-  messages: [{role: "user", content: "What's 15 * 7?"}],
-  tools: [Calculator.new]
-).each_message { puts _1.content }
-```
-
-### Structured Outputs
-
-Constrain Claude's responses to follow a specific JSON schema using the `output_config` parameter:
-
-```ruby
-class FamousNumber < Anthropic::BaseModel
-  required :value, Float
-  optional :reason, String, doc: "why is this number mathematically significant?"
-end
-
-class Output < Anthropic::BaseModel
-  required :numbers, Anthropic::ArrayOf[FamousNumber], min_length: 3, max_length: 5
-end
-
-message = anthropic.messages.create(
-  model: "claude-sonnet-4-5-20250929",
-  max_tokens: 1024,
-  messages: [{role: "user", content: "give me some famous numbers"}],
-  output_config: {format: Output}
-)
-
-# Access the parsed response
-message.parsed_output
-# => #<Output numbers=[#<FamousNumber value=3.14159... reason="Pi is...">...]>
-```
-
-For streaming and more examples, see [helpers.md](helpers.md#structured-outputs).
-
-### Pagination
-
-List methods in the Anthropic API are paginated.
-
-This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:
-
-```ruby
-page = anthropic.messages.batches.list(limit: 20)
-
-# Fetch single item from page.
-batch = page.data[0]
-puts(batch.id)
-
-# Automatically fetches more pages as needed.
-page.auto_paging_each do |batch|
-  puts(batch.id)
-end
-```
-
-Alternatively, you can use the `#next_page?` and `#next_page` methods for more granular control working with pages.
-
-```ruby
-if page.next_page?
-  new_page = page.next_page
-  puts(new_page.data[0].id)
-end
-```
-
-### File uploads
-
-Request parameters that correspond to file uploads can be passed as raw contents, a [`Pathname`](https://rubyapi.org/3.2/o/pathname) instance, [`StringIO`](https://rubyapi.org/3.2/o/stringio), or more.
-
-```ruby
-require "pathname"
-
-# Use `Pathname` to send the filename and/or avoid paging a large file into memory:
-file_metadata = anthropic.beta.files.upload(file: Pathname("/path/to/file"))
-
-# Alternatively, pass file contents or a `StringIO` directly:
-file_metadata = anthropic.beta.files.upload(file: File.read("/path/to/file"))
-
-# Or, to control the filename and/or content type:
-file = Anthropic::FilePart.new(File.read("/path/to/file"), filename: "/path/to/file", content_type: "…")
-file_metadata = anthropic.beta.files.upload(file: file)
-
-puts(file_metadata.id)
-```
-
-Note that you can also pass a raw `IO` descriptor, but this disables retries, as the library can't be sure if the descriptor is a file or pipe (which cannot be rewound).
-
-### Handling errors
-
-When the library is unable to connect to the API, or if the API returns a non-success status code (i.e., 4xx or 5xx response), a subclass of `Anthropic::Errors::APIError` will be thrown:
-
-```ruby
-begin
-  message = anthropic.messages.create(
-    max_tokens: 1024,
-    messages: [{role: "user", content: "Hello, Claude"}],
-    model: "claude-sonnet-4-5-20250929"
-  )
-rescue Anthropic::Errors::APIConnectionError => e
-  puts("The server could not be reached")
-  puts(e.cause)  # an underlying Exception, likely raised within `net/http`
-rescue Anthropic::Errors::RateLimitError => e
-  puts("A 429 status code was received; we should back off a bit.")
-rescue Anthropic::Errors::APIStatusError => e
-  puts("Another non-200-range status code was received")
-  puts(e.status)
-end
-```
-
-Error codes are as follows:
-
-| Cause            | Error Type                 |
-| ---------------- | -------------------------- |
-| HTTP 400         | `BadRequestError`          |
-| HTTP 401         | `AuthenticationError`      |
-| HTTP 403         | `PermissionDeniedError`    |
-| HTTP 404         | `NotFoundError`            |
-| HTTP 409         | `ConflictError`            |
-| HTTP 422         | `UnprocessableEntityError` |
-| HTTP 429         | `RateLimitError`           |
-| HTTP >= 500      | `InternalServerError`      |
-| Other HTTP error | `APIStatusError`           |
-| Timeout          | `APITimeoutError`          |
-| Network error    | `APIConnectionError`       |
-
-### Retries
-
-Certain errors will be automatically retried 2 times by default, with a short exponential backoff.
-
-Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict, 429 Rate Limit, >=500 Internal errors, and timeouts will all be retried by default.
-
-You can use the `max_retries` option to configure or disable this:
-
-```ruby
-# Configure the default for all requests:
-anthropic = Anthropic::Client.new(
-  max_retries: 0 # default is 2
-)
-
-# Or, configure per-request:
-anthropic.messages.create(
-  max_tokens: 1024,
-  messages: [{role: "user", content: "Hello, Claude"}],
-  model: "claude-sonnet-4-5-20250929",
-  request_options: {max_retries: 5}
-)
-```
-
-### Timeouts
-
-By default, requests will time out after 600 seconds. You can use the timeout option to configure or disable this:
-
-```ruby
-# Configure the default for all requests:
-anthropic = Anthropic::Client.new(
-  timeout: nil # default is 600
-)
-
-# Or, configure per-request:
-anthropic.messages.create(
-  max_tokens: 1024,
-  messages: [{role: "user", content: "Hello, Claude"}],
-  model: "claude-sonnet-4-5-20250929",
-  request_options: {timeout: 5}
-)
-```
-
-On timeout, `Anthropic::Errors::APITimeoutError` is raised.
-
-Note that requests that time out are retried by default.
-
-## AWS Bedrock
-
-This library also provides support for the [Anthropic Bedrock API](https://aws.amazon.com/bedrock/claude/) if you install this library with the `aws-sdk-bedrockruntime` gem.
-
-You can then instantiate a separate `Anthropic::BedrockClient` class, and use AWS's standard guide for configuring credentials (see [the aws-sdk-ruby gem README](https://github.com/aws/aws-sdk-ruby?tab=readme-ov-file#configuration) or [AWS Documentation](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/setup-config.html#credchain)). It has the same API as the base `Anthropic::Client` class.
-
-Note that the model ID required is different for Bedrock models, and, depending on the model you want to use, you will need to use either the AWS's model ID for Anthropic models -- which can be found in [AWS's Bedrock model catalog](https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html) -- or an inference profile id (e.g. `us.anthropic.claude-3-5-haiku-20241022-v1:0` for Claude 3.5 Haiku).
-
-```ruby
-require "bundler/setup"
-require "anthropic"
-
-anthropic = Anthropic::BedrockClient.new
-
-message = anthropic.messages.create(
-  max_tokens: 1024,
-  messages: [
-    {
-      role: "user",
-      content: "Hello, Claude"
-    }
-  ],
-  model: "anthropic.claude-sonnet-4-5-20250929-v2:0"
-)
-
-puts(message)
-```
-
-For more examples see [`examples/bedrock`](examples/bedrock).
-
-## Google Vertex
-
-This library also provides support for the [Anthropic Vertex API](https://cloud.google.com/vertex-ai?hl=en) if you install this library with the `googleauth` gem.
-
-You can then import and instantiate a separate `Anthropic::VertexClient` class, and use Google's guide for configuring [Application Default Credentials](https://cloud.google.com/docs/authentication/provide-credentials-adc). It has the same API as the base `Anthropic::Client` class.
-
-```ruby
-require "bundler/setup"
-require "anthropic"
-
-anthropic = Anthropic::VertexClient.new(region: "us-east5", project_id: "my-project-id")
-
-message = anthropic.messages.create(
-  max_tokens: 1024,
-  messages: [
-    {
-      role: "user",
-      content: "Hello, Claude"
-    }
-  ],
-  model: "claude-sonnet-4@20250514"
-)
-
-puts(message)
-```
-
-For more examples see [`examples/vertex`](examples/vertex).
-
-## Advanced concepts
-
-### BaseModel
-
-All parameter and response objects inherit from `Anthropic::Internal::Type::BaseModel`, which provides several conveniences, including:
-
-1. All fields, including unknown ones, are accessible with `obj[:prop]` syntax, and can be destructured with `obj => {prop: prop}` or pattern-matching syntax.
-
-2. Structural equivalence for equality; if two API calls return the same values, comparing the responses with == will return true.
-
-3. Both instances and the classes themselves can be pretty-printed.
-
-4. Helpers such as `#to_h`, `#deep_to_h`, `#to_json`, and `#to_yaml`.
-
-### Making custom or undocumented requests
-
-#### Undocumented properties
-
-You can send undocumented parameters to any endpoint, and read undocumented response properties, like so:
-
-> [!WARNING]
->
-> The `extra_` parameters of the same name overrides the documented parameters. For security reasons, ensure these methods are only used with trusted input data.
-
-```ruby
-message =
-  anthropic.messages.create(
-    max_tokens: 1024,
-    messages: [{role: "user", content: "Hello, Claude"}],
-    model: "claude-sonnet-4-5-20250929",
-    request_options: {
-      extra_query: {my_query_parameter: value},
-      extra_body: {my_body_parameter: value},
-      extra_headers: {"my-header": value}
-    }
-  )
-
-puts(message[:my_undocumented_property])
-```
-
-#### Undocumented request params
-
-If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` under the `request_options:` parameter when making a request, as seen in the examples above.
-
-#### Undocumented endpoints
-
-To make requests to undocumented endpoints while retaining the benefit of auth, retries, and so on, you can make requests using `client.request`, like so:
-
-```ruby
-response = client.request(
-  method: :post,
-  path: '/undocumented/endpoint',
-  query: {"dog": "woof"},
-  headers: {"useful-header": "interesting-value"},
-  body: {"hello": "world"}
-)
-```
-
-### Concurrency & connection pooling
-
-The `Anthropic::Client` instances are threadsafe, but are only are fork-safe when there are no in-flight HTTP requests.
-
-Each instance of `Anthropic::Client` has its own HTTP connection pool with a default size of 99. As such, we recommend instantiating the client once per application in most settings.
-
-When all available connections from the pool are checked out, requests wait for a new connection to become available, with queue time counting towards the request timeout.
-
-Unless otherwise specified, other classes in the SDK do not have locks protecting their underlying data structure.
-
-## Sorbet
-
-This library provides comprehensive [RBI](https://sorbet.org/docs/rbi) definitions, and has no dependency on sorbet-runtime.
-
-You can provide typesafe request parameters like so:
-
-```ruby
-anthropic.messages.create(
-  max_tokens: 1024,
-  messages: [Anthropic::MessageParam.new(role: "user", content: "Hello, Claude")],
-  model: "claude-sonnet-4-5-20250929"
-)
-```
-
-Or, equivalently:
-
-```ruby
-# Hashes work, but are not typesafe:
-anthropic.messages.create(
-  max_tokens: 1024,
-  messages: [{role: "user", content: "Hello, Claude"}],
-  model: "claude-sonnet-4-5-20250929"
-)
-
-# You can also splat a full Params class:
-params = Anthropic::MessageCreateParams.new(
-  max_tokens: 1024,
-  messages: [Anthropic::MessageParam.new(role: "user", content: "Hello, Claude")],
-  model: "claude-sonnet-4-5-20250929"
-)
-anthropic.messages.create(**params)
-```
-
-### Enums
-
-Since this library does not depend on `sorbet-runtime`, it cannot provide [`T::Enum`](https://sorbet.org/docs/tenum) instances. Instead, we provide "tagged symbols" instead, which is always a primitive at runtime:
-
-```ruby
-# :auto
-puts(Anthropic::MessageCreateParams::ServiceTier::AUTO)
-
-# Revealed type: `T.all(Anthropic::MessageCreateParams::ServiceTier, Symbol)`
-T.reveal_type(Anthropic::MessageCreateParams::ServiceTier::AUTO)
-```
-
-Enum parameters have a "relaxed" type, so you can either pass in enum constants or their literal value:
-
-```ruby
-# Using the enum constants preserves the tagged type information:
-anthropic.messages.create(
-  service_tier: Anthropic::MessageCreateParams::ServiceTier::AUTO,
-  # …
-)
-
-# Literal values are also permissible:
-anthropic.messages.create(
-  service_tier: :auto,
-  # …
-)
-```
-
-## Versioning
-
-This package follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions. As the library is in initial development and has a major version of `0`, APIs may change at any time.
-
-This package considers improvements to the (non-runtime) `*.rbi` and `*.rbs` type definitions to be non-breaking changes.
-
 ## Requirements
 
-Ruby 3.2.0 or higher.
+Ruby 3.2.0+
 
 ## Contributing
 
-See [the contributing documentation](https://github.com/anthropics/anthropic-sdk-ruby/tree/main/CONTRIBUTING.md).
+See [CONTRIBUTING.md](./CONTRIBUTING.md).
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
 
 ## Acknowledgements
 
-Thank you [@alexrudall](https://github.com/alexrudall) for giving feedback, donating the `anthropic` Ruby Gem name, and paving the way by building the first Anthropic Ruby SDK.
+Thank you [@alexrudall](https://github.com/alexrudall) for giving feedback, donating the anthropic Ruby Gem name, and paving the way by building the first Anthropic Ruby SDK.

data/lib/anthropic/internal/util.rb

@@ -490,6 +490,37 @@ module Anthropic
       JSONL_CONTENT = %r{^application/(:?x-(?:n|l)djson)|(:?(?:x-)?jsonl)}
 
       class << self
+        # @api private
+        #
+        # @param query [Hash{Symbol=>Object}]
+        #
+        # @return [Hash{Symbol=>Object}]
+        def encode_query_params(query)
+          out = {}
+          query.each { write_query_param_element!(out, _1, _2) }
+          out
+        end
+
+        # @api private
+        #
+        # @param collection [Hash{Symbol=>Object}]
+        # @param key [String]
+        # @param element [Object]
+        #
+        # @return [nil]
+        private def write_query_param_element!(collection, key, element)
+          case element
+          in Hash
+            element.each do |name, value|
+              write_query_param_element!(collection, "#{key}[#{name}]", value)
+            end
+          in Array
+            collection[key] = element.map(&:to_s).join(",")
+          else
+            collection[key] = element.to_s
+          end
+        end
+
         # @api private
         #
         # @param y [Enumerator::Yielder]

data/lib/anthropic/models/beta/beta_code_execution_tool_20250522.rb

@@ -58,6 +58,12 @@ module Anthropic
         #
         #   @param type [Symbol, :code_execution_20250522]
 
+        # Specifies who can invoke a tool.
+        #
+        # Values: direct: The model can call this tool directly. code_execution_20250825:
+        # The tool can be called from the code execution environment (v1).
+        # code_execution_20260120: The tool can be called from the code execution
+        # environment (v2 with persistence).
         module AllowedCaller
           extend Anthropic::Internal::Type::Enum
 

data/lib/anthropic/models/beta/beta_code_execution_tool_20250825.rb

@@ -58,6 +58,12 @@ module Anthropic
         #
         #   @param type [Symbol, :code_execution_20250825]
 
+        # Specifies who can invoke a tool.
+        #
+        # Values: direct: The model can call this tool directly. code_execution_20250825:
+        # The tool can be called from the code execution environment (v1).
+        # code_execution_20260120: The tool can be called from the code execution
+        # environment (v2 with persistence).
         module AllowedCaller
           extend Anthropic::Internal::Type::Enum
 

data/lib/anthropic/models/beta/beta_code_execution_tool_20260120.rb

@@ -61,6 +61,12 @@ module Anthropic
         #
         #   @param type [Symbol, :code_execution_20260120]
 
+        # Specifies who can invoke a tool.
+        #
+        # Values: direct: The model can call this tool directly. code_execution_20250825:
+        # The tool can be called from the code execution environment (v1).
+        # code_execution_20260120: The tool can be called from the code execution
+        # environment (v2 with persistence).
         module AllowedCaller
           extend Anthropic::Internal::Type::Enum
 

data/lib/anthropic/models/beta/beta_iterations_usage.rb

@@ -7,11 +7,13 @@ module Anthropic
       module BetaIterationsUsageItem
         extend Anthropic::Internal::Type::Union
 
+        discriminator :type
+
         # Token usage for a sampling iteration.
-        variant -> { Anthropic::Beta::BetaMessageIterationUsage }
+        variant :message, -> { Anthropic::Beta::BetaMessageIterationUsage }
 
         # Token usage for a compaction iteration.
-        variant -> { Anthropic::Beta::BetaCompactionIterationUsage }
+        variant :compaction, -> { Anthropic::Beta::BetaCompactionIterationUsage }
 
         # @!method self.variants
         #   @return [Array(Anthropic::Models::Beta::BetaMessageIterationUsage, Anthropic::Models::Beta::BetaCompactionIterationUsage)]

data/lib/anthropic/models/beta/beta_memory_tool_20250818.rb

@@ -66,6 +66,12 @@ module Anthropic
         #
         #   @param type [Symbol, :memory_20250818]
 
+        # Specifies who can invoke a tool.
+        #
+        # Values: direct: The model can call this tool directly. code_execution_20250825:
+        # The tool can be called from the code execution environment (v1).
+        # code_execution_20260120: The tool can be called from the code execution
+        # environment (v2 with persistence).
         module AllowedCaller
           extend Anthropic::Internal::Type::Enum