anthropic 1.40.0 → 1.41.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b34378dd9395b126e18915a8ee15526d27d7e7002475e401d8c81bae601289fb
-  data.tar.gz: ed103f7d82d22f04cc7a0332a4a24648beaafcbafbf4e16fa19717ce59c9817c
+  metadata.gz: fc1a7f57c129c15f70a549ddb40df06a00fab53532406c86722ec253de5247cc
+  data.tar.gz: e70e7a9bcd6e5fbc5f9bc904a7475cde990e7e9f393d232c2f2e4e53ec74cc62
 SHA512:
-  metadata.gz: 6740871a358a65e3948a1381ba601ad342f4f1418c19af0e9c6badf1c91e7d4aec51650f5d202a3f31d44b39f4c951a85875d4208227281ceb0d7da0b7a9c0d8
-  data.tar.gz: b596807165dbd16f19fe9902451b0e6e9b346030265214d1c5eece6e1d4eb8ee7c3fd9cf650d06ca7695eac94103b4669f8b130970b0fe5ca61022ea4ba0630f
+  metadata.gz: 76e09bc1ab37e2aed7659956e5cfa1c0511e5947940e76c1c465b5098c6bb50526d8b918f4d4c7a677a7eabfb71e557118e02dd3b55cf639c3a6958433706627
+  data.tar.gz: bcf9f66aae233ecb1dde11d4468cfc557529688a0490bde5d01036a1c87b480fc2a2814e487f34ff27640ef089f3ccbb7a3395bc0757d3d99fac5b0245479cbd

data/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Changelog
 
+## 1.41.0 (2026-05-13)
+
+Full Changelog: [v1.40.0...v1.41.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.40.0...v1.41.0)
+
+### Features
+
+* **api:** Add BetaManagedAgentsSearchResultBlock types ([1432542](https://github.com/anthropics/anthropic-sdk-ruby/commit/1432542b303269f23d35e5b6891518a32b5fa934))
+* **api:** Add support for cache diagnostics beta ([7ada493](https://github.com/anthropics/anthropic-sdk-ruby/commit/7ada4935e83b955b2f0b19e2940bc7dc3d336bc1))
+* **mcp:** add mcp helpers ([#934](https://github.com/anthropics/anthropic-sdk-ruby/issues/934)) ([de5b608](https://github.com/anthropics/anthropic-sdk-ruby/commit/de5b60875486a62534fb95ca13153819c601af92))
+
+
+### Bug Fixes
+
+* avoid gzip buffering during streaming on non-beta messages ([#936](https://github.com/anthropics/anthropic-sdk-ruby/issues/936)) ([8b7f779](https://github.com/anthropics/anthropic-sdk-ruby/commit/8b7f779bd9bdfc7693de679832531c32c215909a))
+* **client:** elide content type header on requests without body ([c58745a](https://github.com/anthropics/anthropic-sdk-ruby/commit/c58745aea5725531ba89aac2d64b3914232833c2))
+* handle syntax updates for ruby 4's PRISM parser ([#189](https://github.com/anthropics/anthropic-sdk-ruby/issues/189)) ([772dd65](https://github.com/anthropics/anthropic-sdk-ruby/commit/772dd65733bfd2869f846b6a9734776ed87ee7d6))
+
+
+### Chores
+
+* **api:** spec updates ([0e85c3f](https://github.com/anthropics/anthropic-sdk-ruby/commit/0e85c3f8064dd1951ef00c06ac9a709f7067eb70))
+
 ## 1.40.0 (2026-05-11)
 
 Full Changelog: [v1.39.0...v1.40.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.39.0...v1.40.0)

data/README.md

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

data/lib/anthropic/credentials/workload_identity.rb

@@ -158,7 +158,7 @@ module Anthropic
         data = JSON.parse(response.body, symbolize_names: true)
         token, expires_in =
           case data
-          in {access_token: String => token, expires_in: Integer | String => expires_in}
+          in {access_token: String => token, expires_in: (Integer | String) => expires_in}
             [token, expires_in.to_i]
           in {access_token: String => token}
             [token, 3600]

data/lib/anthropic/helpers/messages.rb

@@ -35,8 +35,20 @@ module Anthropic
 
           case data
           in {tools: Array => tool_array}
+            # rubocop:disable Metrics/BlockLength
             mapped = tool_array.map do |tool|
               case tool
+              # BaseTool whose class declares an explicit `tool_name` (e.g. MCP-built tools):
+              in Anthropic::Helpers::Tools::BaseTool if tool.class.tool_name
+                name = tool.class.tool_name
+                description = tool.class.doc_string
+                tools.store(name, tool)
+                input_schema = Anthropic::Helpers::InputSchema::JsonSchemaConverter.to_json_schema(tool)
+                extras = tool.class.tool_extra_props || {}
+                result = {name:, input_schema:, **extras}
+                result[:description] = description if description
+                result[:strict] = strict if strict
+                result
               # Direct tool class:
               in Anthropic::Helpers::InputSchema::JsonSchemaConverter
                 classname = tool.is_a?(Anthropic::Helpers::Tools::BaseTool) ? tool.class.name : tool.name
@@ -68,6 +80,7 @@ module Anthropic
                 tool
               end
             end
+            # rubocop:enable Metrics/BlockLength
             tool_array.replace(mapped)
           # GA: output_config with BaseModel class as format
           in {output_config: {format: Anthropic::Helpers::InputSchema::JsonSchemaConverter => model} => output_config}

data/lib/anthropic/helpers/tools/base_tool.rb

@@ -16,6 +16,24 @@ module Anthropic
           # @return [String]
           attr_reader :doc_string
 
+          # @api private
+          #
+          # When set, the runner uses this literal string as the API tool name instead of
+          # snake-casing the class name. Used by helpers (e.g. MCP) that build tools
+          # dynamically from an external definition.
+          #
+          # @return [String, nil]
+          attr_accessor :tool_name
+
+          # @api private
+          #
+          # Extra tool-definition properties merged into the API payload (e.g.
+          # `cache_control`, `defer_loading`, `allowed_callers`, `eager_input_streaming`,
+          # `input_examples`, `strict`).
+          #
+          # @return [Hash{Symbol=>Object}, nil]
+          attr_accessor :tool_extra_props
+
           # @api public
           #
           # @param description [String]

data/lib/anthropic/helpers/tools/mcp.rb

@@ -0,0 +1,485 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module Tools
+      # Helpers for integrating Model Context Protocol (MCP) servers with the
+      # Anthropic SDK.
+      #
+      # These helpers convert types returned by the `mcp` gem into the shapes
+      # the Beta Messages API accepts, so you don't have to write glue code
+      # yourself.
+      #
+      # The `mcp` gem is an optional dependency; install it separately:
+      #
+      #     gem install mcp
+      #
+      # @example Convert MCP tools and run them through `tool_runner`
+      #   require "mcp"
+      #   require "anthropic"
+      #
+      #   transport  = MCP::Client::HTTP.new(url: "https://example.com/mcp")
+      #   mcp_client = MCP::Client.new(transport: transport)
+      #   anthropic  = Anthropic::Client.new
+      #
+      #   runner = anthropic.beta.messages.tool_runner(
+      #     model: "claude-sonnet-4-5",
+      #     max_tokens: 1024,
+      #     messages: [{role: "user", content: "Use the available tools"}],
+      #     tools: Anthropic::Mcp.tools(mcp_client.tools, mcp_client)
+      #   )
+      #   runner.run_until_finished
+      module Mcp
+        SUPPORTED_IMAGE_TYPES = Set.new(%w[image/jpeg image/png image/gif image/webp]).freeze
+
+        # Raised when an MCP value cannot be converted to a format supported by
+        # the Claude API.
+        class UnsupportedMCPValueError < Anthropic::Errors::Error; end
+
+        # @api private
+        #
+        # Runnable tool backing {Anthropic::Mcp.tool}. Each call to {build} produces
+        # a fresh anonymous subclass — that subclass owns a unique inner "parsed
+        # input" class so the runner can dispatch tool calls via
+        # `class.model === tool_use.parsed`, the same path used by hand-written
+        # {Anthropic::BaseTool} subclasses.
+        class Tool < Anthropic::Helpers::Tools::BaseTool
+          class << self
+            attr_accessor :mcp_input_schema, :mcp_client
+          end
+
+          def self.build(
+            mcp_tool:,
+            mcp_client:,
+            cache_control: nil,
+            defer_loading: nil,
+            allowed_callers: nil,
+            eager_input_streaming: nil,
+            input_examples: nil,
+            strict: nil
+          )
+            api_name, description, raw_schema = Mcp.send(:extract_tool_fields, mcp_tool)
+            raise ArgumentError, "MCP tool is missing a `name`" if api_name.to_s.empty?
+
+            extras = {
+              cache_control: cache_control,
+              defer_loading: defer_loading,
+              allowed_callers: allowed_callers,
+              eager_input_streaming: eager_input_streaming,
+              input_examples: input_examples,
+              strict: strict
+            }.compact
+
+            input_class = Class.new(Hash)
+
+            klass = Class.new(self)
+            klass.description(description) if description
+            klass.tool_name = api_name
+            klass.tool_extra_props = extras
+            klass.mcp_input_schema = Mcp.send(:normalize_schema, raw_schema)
+            klass.mcp_client = mcp_client
+            klass.instance_variable_set(:@model, input_class)
+            klass.new
+          end
+
+          # Return a deep copy of the raw schema; `SupportedSchemas.transform_schema!`
+          # mutates the hash it receives.
+          def to_json_schema_inner(state:)
+            _ = state
+            Marshal.load(Marshal.dump(self.class.mcp_input_schema))
+          end
+
+          def to_json_schema
+            Anthropic::Helpers::InputSchema::JsonSchemaConverter.to_json_schema(self)
+          end
+
+          # MCP arguments are opaque JSON objects — pass through unchanged. The
+          # returned object is an instance of this subclass's per-tool `model`,
+          # which is both a Hash (for downstream serialization) and uniquely
+          # typed so the runner can identify which MCP tool the parsed input
+          # belongs to.
+          def coerce(value, state:)
+            state.fetch(:exactness)[:yes] += 1
+            wrapper = self.class.model.new
+            input = if value.is_a?(Hash)
+              value
+            else
+              (value.respond_to?(:to_h) ? value.to_h : {})
+            end
+            input.each { |k, v| wrapper[k] = v }
+            wrapper
+          end
+
+          def call(parsed)
+            args = parsed.is_a?(Hash) ? parsed.to_h : parsed
+            response = self.class.mcp_client.call_tool(name: self.class.tool_name, arguments: args)
+            Mcp.send(:convert_tool_result, response)
+          end
+        end
+
+        class << self
+          # Convert an MCP tool definition into a runnable tool for `tool_runner`.
+          #
+          # @param mcp_tool [MCP::Client::Tool, Hash] An MCP tool, typically from
+          #   `mcp_client.list_tools` / `mcp_client.tools`. May be a typed
+          #   `MCP::Client::Tool` or a hash with `:name`, `:description`,
+          #   `:input_schema` (or `:inputSchema`).
+          # @param mcp_client [#call_tool] The MCP client used to invoke the tool.
+          # @param cache_control [Hash, nil] Prompt-caching control passed through
+          #   to the tool definition.
+          # @param defer_loading [Boolean, nil] If true, the tool is excluded
+          #   from the initial system prompt.
+          # @param allowed_callers [Array<Symbol, String>, nil] Restricts which
+          #   callers may invoke the tool.
+          # @param eager_input_streaming [Boolean, nil] Enables eager input
+          #   streaming for the tool.
+          # @param input_examples [Array<Hash>, nil] Example inputs for the tool.
+          # @param strict [Boolean, nil] When true, guarantees schema validation
+          #   on tool names and inputs.
+          # @return [Anthropic::Helpers::Tools::Mcp::Tool]
+          def tool(
+            mcp_tool,
+            mcp_client,
+            cache_control: nil,
+            defer_loading: nil,
+            allowed_callers: nil,
+            eager_input_streaming: nil,
+            input_examples: nil,
+            strict: nil
+          )
+            require_mcp!
+            Tool.build(
+              mcp_tool: mcp_tool,
+              mcp_client: mcp_client,
+              cache_control: cache_control,
+              defer_loading: defer_loading,
+              allowed_callers: allowed_callers,
+              eager_input_streaming: eager_input_streaming,
+              input_examples: input_examples,
+              strict: strict
+            )
+          end
+
+          # Convert a list of MCP tools into runnable tools.
+          #
+          # @param mcp_tools [Array<MCP::Client::Tool, Hash>]
+          # @param mcp_client [#call_tool]
+          # @return [Array<Anthropic::Helpers::Tools::Mcp::Tool>]
+          def tools(mcp_tools, mcp_client, **opts)
+            mcp_tools.map { tool(_1, mcp_client, **opts) }
+          end
+
+          # Convert an MCP prompt message into a Beta message parameter.
+          #
+          # @param mcp_message [MCP::Prompt::Message, Hash]
+          # @param cache_control [Hash, nil] Forwarded to the produced content block.
+          # @return [Hash]
+          def message(mcp_message, cache_control: nil)
+            require_mcp!
+            h = to_hash!(mcp_message, "MCP prompt message")
+            role = hkey(h, :role)
+            role = role.to_sym if role.respond_to?(:to_sym)
+            {
+              role: role,
+              content: [content(hkey(h, :content), cache_control: cache_control)]
+            }
+          end
+
+          # Convert a single MCP content item into a Beta content block.
+          #
+          # Handles text, image, and embedded resource content types. Raises
+          # {UnsupportedMCPValueError} for audio or resource_link types.
+          #
+          # @param mcp_content [MCP::Content::Text, MCP::Content::Image,
+          #   MCP::Content::EmbeddedResource, Hash]
+          # @param cache_control [Hash, nil]
+          # @return [Hash]
+          def content(mcp_content, cache_control: nil)
+            require_mcp!
+            h = to_hash!(mcp_content, "MCP content")
+            block = convert_content(h)
+            block[:cache_control] = cache_control if cache_control
+            block
+          end
+
+          # Convert MCP resource read results into Beta content blocks — one
+          # per item in `contents`. Raises {UnsupportedMCPValueError} on any
+          # item whose MIME type is unsupported.
+          #
+          # @param result [Hash, Array, #contents] The result from
+          #   `mcp_client.read_resource(uri: ...)`. The `mcp` gem returns just
+          #   the contents array — both that and a `{contents: [...]}` hash are
+          #   accepted.
+          # @param cache_control [Hash, nil] Forwarded to each produced block.
+          # @return [Array<Hash>]
+          def resource_to_contents(result, cache_control: nil)
+            require_mcp!
+            contents = extract_resource_contents(result)
+            if contents.empty?
+              raise UnsupportedMCPValueError,
+                    "Resource contents array must contain at least one item"
+            end
+
+            contents.map do |item|
+              block = resource_contents_to_block(to_hash!(item, "resource"))
+              block[:cache_control] = cache_control if cache_control
+              block
+            end
+          end
+
+          # Convert MCP resource read results into {Anthropic::FilePart}
+          # instances suitable for `client.beta.files.upload(file: ...)`. No
+          # MIME filtering — every item in `contents` becomes a file.
+          #
+          # @param result [Hash, Array, #contents]
+          # @return [Array<Anthropic::FilePart>]
+          def resource_to_files(result)
+            require_mcp!
+            contents = extract_resource_contents(result)
+            if contents.empty?
+              raise UnsupportedMCPValueError,
+                    "Resource contents array must contain at least one item"
+            end
+
+            contents.map do |item|
+              resource = to_hash!(item, "resource")
+              Anthropic::FilePart.new(
+                StringIO.new(resource_bytes(resource)),
+                filename: filename_from_uri(hkey(resource, :uri)),
+                content_type: hkey(resource, :mimeType)
+              )
+            end
+          end
+
+          # @api private
+          # Called by {Tool#call}; converts a JSON-RPC `tools/call` response
+          # into the value the tool runner expects.
+          def convert_tool_result(response)
+            result = nested_result(response)
+            is_error = hkey(result, :isError)
+            content_items = hkey(result, :content) || []
+            structured = hkey(result, :structuredContent)
+
+            if is_error
+              blocks = content_items.map { content(_1) }
+              raise Anthropic::Errors::Error, render_error_blocks(blocks)
+            end
+
+            return JSON.generate(structured) if content_items.empty? && structured
+
+            content_items.map { content(_1) }
+          end
+
+          # -- conversion internals -------------------------------------------
+
+          private def convert_content(h)
+            type = hkey(h, :type).to_s
+            case type
+            when "text"
+              text = hkey(h, :text)
+              {type: :text, text: text.to_s}
+            when "image"
+              data = hkey(h, :data)
+              mime = hkey(h, :mimeType)
+              unless supported_image_mime?(mime)
+                raise UnsupportedMCPValueError, "Unsupported image MIME type: #{mime}"
+              end
+              {type: :image, source: {type: :base64, data: data, media_type: mime}}
+            when "resource"
+              resource = hkey(h, :resource)
+              resource_contents_to_block(to_hash!(resource, "embedded resource"))
+            else
+              # Covers "audio", "resource_link", and any unrecognized type.
+              raise UnsupportedMCPValueError, "Unsupported MCP content type: #{type}"
+            end
+          end
+
+          private def resource_contents_to_block(resource)
+            mime = hkey(resource, :mimeType)
+            uri = hkey(resource, :uri)
+            text = hkey(resource, :text)
+            # `mcp/sdk` schema uses `blob`; the Ruby `mcp` gem's BlobContents#to_h also uses `blob`.
+            blob = hkey(resource, :blob)
+
+            if mime && supported_image_mime?(mime)
+              if blob.nil?
+                raise UnsupportedMCPValueError,
+                      "Image resource must have blob data, not text. URI: #{uri}"
+              end
+              return {type: :image, source: {type: :base64, data: blob, media_type: mime}}
+            end
+
+            if mime == "application/pdf"
+              if blob.nil?
+                raise UnsupportedMCPValueError,
+                      "PDF resource must have blob data, not text. URI: #{uri}"
+              end
+              return {type: :document, source: {type: :base64, data: blob, media_type: "application/pdf"}}
+            end
+
+            if mime.nil? || mime.start_with?("text/")
+              data = if !text.nil?
+                text.to_s
+              elsif !blob.nil?
+                Base64.decode64(blob.to_s).force_encoding(Encoding::UTF_8)
+              else
+                ""
+              end
+              return {type: :document, source: {type: :text, data: data, media_type: "text/plain"}}
+            end
+
+            raise UnsupportedMCPValueError, "Unsupported MIME type \"#{mime}\" for resource: #{uri}"
+          end
+
+          private def extract_resource_contents(result)
+            case result
+            when Array
+              result
+            when Hash
+              result[:contents] || result["contents"] || []
+            else
+              if result.respond_to?(:contents)
+                result.contents
+              elsif result.respond_to?(:to_h)
+                h = result.to_h
+                h[:contents] || h["contents"] || []
+              else
+                []
+              end
+            end
+          end
+
+          private def resource_bytes(resource)
+            text = hkey(resource, :text)
+            blob = hkey(resource, :blob)
+
+            return Base64.decode64(blob.to_s) unless blob.nil?
+            return text.to_s.dup.force_encoding(Encoding::UTF_8) unless text.nil?
+
+            "".dup
+          end
+
+          private def filename_from_uri(uri)
+            return "file" if uri.nil? || uri.to_s.empty?
+
+            path =
+              begin
+                URI.parse(uri.to_s).path
+              rescue URI::InvalidURIError
+                uri.to_s
+              end
+            base = path.to_s.split("/").last
+            base.nil? || base.empty? ? "file" : base
+          end
+
+          private def render_error_blocks(blocks)
+            parts = blocks.map do |b|
+              if b[:type] == :text
+                b[:text].to_s
+              else
+                JSON.generate(b)
+              end
+            end
+            joined = parts.reject(&:empty?).join("\n")
+            joined.empty? ? "MCP tool reported an error" : joined
+          end
+
+          private def nested_result(response)
+            return {} if response.nil?
+
+            r = response
+            r = r["result"] || r[:result] || r if r.is_a?(Hash) && (r.key?("result") || r.key?(:result))
+            r.is_a?(Hash) ? r : {}
+          end
+
+          # -- input shape helpers --------------------------------------------
+
+          private def extract_tool_fields(mcp_tool)
+            if mcp_tool.is_a?(Hash)
+              [
+                hkey(mcp_tool, :name),
+                hkey(mcp_tool, :description),
+                hkey(mcp_tool, :input_schema) || hkey(mcp_tool, :inputSchema)
+              ]
+            else
+              name = mcp_tool.respond_to?(:name) ? mcp_tool.name : nil
+              description = mcp_tool.respond_to?(:description) ? mcp_tool.description : nil
+              schema =
+                if mcp_tool.respond_to?(:input_schema)
+                  mcp_tool.input_schema
+                elsif mcp_tool.respond_to?(:inputSchema)
+                  mcp_tool.inputSchema
+                end
+              [name, description, schema]
+            end
+          end
+
+          # `mcp/sdk` requires `properties` and `required` to be present (even
+          # if null) on the API side. Normalize the gem's string-keyed
+          # JSON-Schema hashes into the symbol-keyed shape the SDK serializes.
+          private def normalize_schema(raw)
+            schema = raw.nil? ? {} : deep_symbolize_keys(raw)
+            schema[:type] ||= :object
+            schema[:properties] = nil unless schema.key?(:properties)
+            schema[:required] = nil unless schema.key?(:required)
+            schema
+          end
+
+          private def deep_symbolize_keys(obj)
+            case obj
+            in Hash
+              obj.each_with_object({}) do |(k, v), acc|
+                key = k.is_a?(String) ? k.to_sym : k
+                acc[key] = deep_symbolize_keys(v)
+              end
+            in Array
+              obj.map { deep_symbolize_keys(_1) }
+            else
+              obj
+            end
+          end
+
+          # Reads a value from a hash that may use either symbol or string keys.
+          # The Ruby `mcp` gem returns string-keyed hashes from transport layers
+          # but symbol-keyed hashes from typed objects' `to_h`.
+          private def hkey(h, key)
+            return nil unless h.is_a?(Hash)
+
+            sym = key.to_sym
+            str = key.to_s
+            return h[sym] if h.key?(sym)
+            return h[str] if h.key?(str)
+
+            nil
+          end
+
+          private def to_hash!(obj, label)
+            return obj if obj.is_a?(Hash)
+            return obj.to_h if obj.respond_to?(:to_h)
+
+            raise UnsupportedMCPValueError,
+                  "Expected #{label} to be a Hash or to-hashable object, got #{obj.class}"
+          end
+
+          private def supported_image_mime?(mime)
+            return false unless mime.is_a?(String)
+
+            SUPPORTED_IMAGE_TYPES.include?(mime)
+          end
+
+          private def require_mcp!
+            return if defined?(::MCP)
+
+            begin
+              require("mcp")
+            rescue LoadError
+              raise LoadError,
+                    "The `mcp` gem is required to use Anthropic's MCP helpers. " \
+                    "Install it by adding `gem \"mcp\"` to your Gemfile (or running `gem install mcp`)."
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -310,6 +310,8 @@ module Anthropic
               Anthropic::Internal::Util.deep_merge(*[req[:body], opts[:extra_body]].compact)
             end
 
+          headers.delete("content-type") if body.nil?
+
           url = Anthropic::Internal::Util.join_parsed_uri(
             @base_url_components,
             {**req, path: path, query: query}

data/lib/anthropic/mcp.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Anthropic
+  Mcp = Anthropic::Helpers::Tools::Mcp
+end

data/lib/anthropic/models/anthropic_beta.rb

@@ -55,6 +55,8 @@ module Anthropic
 
       variant const: -> { Anthropic::Models::AnthropicBeta::MANAGED_AGENTS_2026_04_01 }
 
+      variant const: -> { Anthropic::Models::AnthropicBeta::CACHE_DIAGNOSIS_2026_04_07 }
+
       # @!method self.variants
       #   @return [Array(String, Symbol)]
 
@@ -88,6 +90,7 @@ module Anthropic
       USER_PROFILES_2026_03_24 = :"user-profiles-2026-03-24"
       ADVISOR_TOOL_2026_03_01 = :"advisor-tool-2026-03-01"
       MANAGED_AGENTS_2026_04_01 = :"managed-agents-2026-04-01"
+      CACHE_DIAGNOSIS_2026_04_07 = :"cache-diagnosis-2026-04-07"
 
       # @!endgroup
     end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    module Beta
+      class BetaCacheMissMessagesChanged < Anthropic::Internal::Type::BaseModel
+        # @!attribute cache_missed_input_tokens
+        #   Approximate number of input tokens that would have been read from cache had the
+        #   prefix matched the previous request.
+        #
+        #   @return [Integer]
+        required :cache_missed_input_tokens, Integer
+
+        # @!attribute type
+        #
+        #   @return [Symbol, :messages_changed]
+        required :type, const: :messages_changed
+
+        # @!method initialize(cache_missed_input_tokens:, type: :messages_changed)
+        #   Some parameter documentations has been truncated, see
+        #   {Anthropic::Models::Beta::BetaCacheMissMessagesChanged} for more details.
+        #
+        #   @param cache_missed_input_tokens [Integer] Approximate number of input tokens that would have been read from cache had the
+        #
+        #   @param type [Symbol, :messages_changed]
+      end
+    end
+
+    BetaCacheMissMessagesChanged = Beta::BetaCacheMissMessagesChanged
+  end
+end