anthropic-sdk-beta 0.1.0.pre.beta.3

data/lib/anthropic/models/url_pdf_source.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class URLPDFSource < Anthropic::Internal::Type::BaseModel
+      # @!attribute type
+      #
+      #   @return [Symbol, :url]
+      required :type, const: :url
+
+      # @!attribute url
+      #
+      #   @return [String]
+      required :url, String
+
+      # @!parse
+      #   # @param url [String]
+      #   # @param type [Symbol, :url]
+      #   #
+      #   def initialize(url:, type: :url, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/usage.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class Usage < Anthropic::Internal::Type::BaseModel
+      # @!attribute cache_creation_input_tokens
+      #   The number of input tokens used to create the cache entry.
+      #
+      #   @return [Integer, nil]
+      required :cache_creation_input_tokens, Integer, nil?: true
+
+      # @!attribute cache_read_input_tokens
+      #   The number of input tokens read from the cache.
+      #
+      #   @return [Integer, nil]
+      required :cache_read_input_tokens, Integer, nil?: true
+
+      # @!attribute input_tokens
+      #   The number of input tokens which were used.
+      #
+      #   @return [Integer]
+      required :input_tokens, Integer
+
+      # @!attribute output_tokens
+      #   The number of output tokens which were used.
+      #
+      #   @return [Integer]
+      required :output_tokens, Integer
+
+      # @!parse
+      #   # @param cache_creation_input_tokens [Integer, nil]
+      #   # @param cache_read_input_tokens [Integer, nil]
+      #   # @param input_tokens [Integer]
+      #   # @param output_tokens [Integer]
+      #   #
+      #   def initialize(cache_creation_input_tokens:, cache_read_input_tokens:, input_tokens:, output_tokens:, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/request_options.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Anthropic
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Anthropic::Internal::Type::BaseModel
+    # @api private
+    #
+    # @param opts [Anthropic::RequestOptions, Hash{Symbol=>Object}]
+    #
+    # @raise [ArgumentError]
+    def self.validate!(opts)
+      case opts
+      in Anthropic::RequestOptions | Hash
+        opts.to_h.each_key do |k|
+          unless fields.include?(k)
+            raise ArgumentError.new("Request `opts` keys must be one of #{fields.keys}, got #{k.inspect}")
+          end
+        end
+      else
+        raise ArgumentError.new("Request `opts` must be a Hash or RequestOptions, got #{opts.inspect}")
+      end
+    end
+
+    # @!attribute idempotency_key
+    #   Idempotency key to send with request and all associated retries. Will only be
+    #   sent for write requests.
+    #
+    #   @return [String, nil]
+    optional :idempotency_key, String
+
+    # @!attribute extra_query
+    #   Extra query params to send with the request. These are `.merge`’d into any
+    #   `query` given at the client level.
+    #
+    #   @return [Hash{String=>Array<String>, String, nil}, nil]
+    optional :extra_query, Anthropic::Internal::Type::HashOf[Anthropic::Internal::Type::ArrayOf[String]]
+
+    # @!attribute extra_headers
+    #   Extra headers to send with the request. These are `.merged`’d into any
+    #   `extra_headers` given at the client level.
+    #
+    #   @return [Hash{String=>String, nil}, nil]
+    optional :extra_headers, Anthropic::Internal::Type::HashOf[String, nil?: true]
+
+    # @!attribute extra_body
+    #   Extra data to send with the request. These are deep merged into any data
+    #   generated as part of the normal request.
+    #
+    #   @return [Object, nil]
+    optional :extra_body, Anthropic::Internal::Type::HashOf[Anthropic::Internal::Type::Unknown]
+
+    # @!attribute max_retries
+    #   Maximum number of retries to attempt after a failed initial request.
+    #
+    #   @return [Integer, nil]
+    optional :max_retries, Integer
+
+    # @!attribute timeout
+    #   Request timeout in seconds.
+    #
+    #   @return [Float, nil]
+    optional :timeout, Float
+
+    # @!parse
+    #   # Returns a new instance of RequestOptions.
+    #   #
+    #   # @param values [Hash{Symbol=>Object}]
+    #   #
+    #   def initialize(values = {}) = super
+  end
+end

data/lib/anthropic/resources/beta/messages/batches.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Resources
+    class Beta
+      class Messages
+        class Batches
+          # Send a batch of Message creation requests.
+          #
+          # The Message Batches API can be used to process multiple Messages API requests at
+          # once. Once a Message Batch is created, it begins processing immediately. Batches
+          # can take up to 24 hours to complete.
+          #
+          # Learn more about the Message Batches API in our
+          # [user guide](/en/docs/build-with-claude/batch-processing)
+          #
+          # @overload create(requests:, betas: nil, request_options: {})
+          #
+          # @param requests [Array<Anthropic::Models::Beta::Messages::BatchCreateParams::Request>]
+          # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>]
+          # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Anthropic::Models::Beta::Messages::BetaMessageBatch]
+          #
+          # @see Anthropic::Models::Beta::Messages::BatchCreateParams
+          def create(params)
+            parsed, options = Anthropic::Models::Beta::Messages::BatchCreateParams.dump_request(params)
+            header_params = {betas: "anthropic-beta"}
+            @client.request(
+              method: :post,
+              path: "v1/messages/batches?beta=true",
+              headers: parsed.slice(*header_params.keys).transform_keys(header_params),
+              body: parsed.except(*header_params.keys),
+              model: Anthropic::Models::Beta::Messages::BetaMessageBatch,
+              options: options
+            )
+          end
+
+          # This endpoint is idempotent and can be used to poll for Message Batch
+          # completion. To access the results of a Message Batch, make a request to the
+          # `results_url` field in the response.
+          #
+          # Learn more about the Message Batches API in our
+          # [user guide](/en/docs/build-with-claude/batch-processing)
+          #
+          # @overload retrieve(message_batch_id, betas: nil, request_options: {})
+          #
+          # @param message_batch_id [String]
+          # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>]
+          # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Anthropic::Models::Beta::Messages::BetaMessageBatch]
+          #
+          # @see Anthropic::Models::Beta::Messages::BatchRetrieveParams
+          def retrieve(message_batch_id, params = {})
+            parsed, options = Anthropic::Models::Beta::Messages::BatchRetrieveParams.dump_request(params)
+            @client.request(
+              method: :get,
+              path: ["v1/messages/batches/%1$s?beta=true", message_batch_id],
+              headers: parsed.transform_keys(betas: "anthropic-beta"),
+              model: Anthropic::Models::Beta::Messages::BetaMessageBatch,
+              options: options
+            )
+          end
+
+          # List all Message Batches within a Workspace. Most recently created batches are
+          # returned first.
+          #
+          # Learn more about the Message Batches API in our
+          # [user guide](/en/docs/build-with-claude/batch-processing)
+          #
+          # @overload list(after_id: nil, before_id: nil, limit: nil, betas: nil, request_options: {})
+          #
+          # @param after_id [String]
+          # @param before_id [String]
+          # @param limit [Integer]
+          # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>]
+          # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Anthropic::Internal::Page<Anthropic::Models::Beta::Messages::BetaMessageBatch>]
+          #
+          # @see Anthropic::Models::Beta::Messages::BatchListParams
+          def list(params = {})
+            parsed, options = Anthropic::Models::Beta::Messages::BatchListParams.dump_request(params)
+            query_params = [:after_id, :before_id, :limit]
+            @client.request(
+              method: :get,
+              path: "v1/messages/batches?beta=true",
+              query: parsed.slice(*query_params),
+              headers: parsed.except(*query_params).transform_keys(betas: "anthropic-beta"),
+              page: Anthropic::Internal::Page,
+              model: Anthropic::Models::Beta::Messages::BetaMessageBatch,
+              options: options
+            )
+          end
+
+          # Delete a Message Batch.
+          #
+          # Message Batches can only be deleted once they've finished processing. If you'd
+          # like to delete an in-progress batch, you must first cancel it.
+          #
+          # Learn more about the Message Batches API in our
+          # [user guide](/en/docs/build-with-claude/batch-processing)
+          #
+          # @overload delete(message_batch_id, betas: nil, request_options: {})
+          #
+          # @param message_batch_id [String]
+          # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>]
+          # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Anthropic::Models::Beta::Messages::BetaDeletedMessageBatch]
+          #
+          # @see Anthropic::Models::Beta::Messages::BatchDeleteParams
+          def delete(message_batch_id, params = {})
+            parsed, options = Anthropic::Models::Beta::Messages::BatchDeleteParams.dump_request(params)
+            @client.request(
+              method: :delete,
+              path: ["v1/messages/batches/%1$s?beta=true", message_batch_id],
+              headers: parsed.transform_keys(betas: "anthropic-beta"),
+              model: Anthropic::Models::Beta::Messages::BetaDeletedMessageBatch,
+              options: options
+            )
+          end
+
+          # Batches may be canceled any time before processing ends. Once cancellation is
+          # initiated, the batch enters a `canceling` state, at which time the system may
+          # complete any in-progress, non-interruptible requests before finalizing
+          # cancellation.
+          #
+          # The number of canceled requests is specified in `request_counts`. To determine
+          # which requests were canceled, check the individual results within the batch.
+          # Note that cancellation may not result in any canceled requests if they were
+          # non-interruptible.
+          #
+          # Learn more about the Message Batches API in our
+          # [user guide](/en/docs/build-with-claude/batch-processing)
+          #
+          # @overload cancel(message_batch_id, betas: nil, request_options: {})
+          #
+          # @param message_batch_id [String]
+          # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>]
+          # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Anthropic::Models::Beta::Messages::BetaMessageBatch]
+          #
+          # @see Anthropic::Models::Beta::Messages::BatchCancelParams
+          def cancel(message_batch_id, params = {})
+            parsed, options = Anthropic::Models::Beta::Messages::BatchCancelParams.dump_request(params)
+            @client.request(
+              method: :post,
+              path: ["v1/messages/batches/%1$s/cancel?beta=true", message_batch_id],
+              headers: parsed.transform_keys(betas: "anthropic-beta"),
+              model: Anthropic::Models::Beta::Messages::BetaMessageBatch,
+              options: options
+            )
+          end
+
+          # Streams the results of a Message Batch as a `.jsonl` file.
+          #
+          # Each line in the file is a JSON object containing the result of a single request
+          # in the Message Batch. Results are not guaranteed to be in the same order as
+          # requests. Use the `custom_id` field to match results to requests.
+          #
+          # Learn more about the Message Batches API in our
+          # [user guide](/en/docs/build-with-claude/batch-processing)
+          #
+          # @overload results_streaming(message_batch_id, betas: nil, request_options: {})
+          #
+          # @param message_batch_id [String]
+          # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>]
+          # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+          #
+          # @return [Anthropic::Internal::JsonLStream<Anthropic::Models::Beta::Messages::BetaMessageBatchIndividualResponse>]
+          #
+          # @see Anthropic::Models::Beta::Messages::BatchResultsParams
+          def results_streaming(message_batch_id, params = {})
+            parsed, options = Anthropic::Models::Beta::Messages::BatchResultsParams.dump_request(params)
+            @client.request(
+              method: :get,
+              path: ["v1/messages/batches/%1$s/results?beta=true", message_batch_id],
+              headers: {"accept" => "application/x-jsonl", **parsed}.transform_keys(betas: "anthropic-beta"),
+              stream: Anthropic::Internal::JsonLStream,
+              model: Anthropic::Models::Beta::Messages::BetaMessageBatchIndividualResponse,
+              options: options
+            )
+          end
+
+          # @api private
+          #
+          # @param client [Anthropic::Client]
+          def initialize(client:)
+            @client = client
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/resources/beta/messages.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Resources
+    class Beta
+      class Messages
+        # @return [Anthropic::Resources::Beta::Messages::Batches]
+        attr_reader :batches
+
+        # See {Anthropic::Resources::Beta::Messages#stream_raw} for streaming counterpart.
+        #
+        # Send a structured list of input messages with text and/or image content, and the
+        # model will generate the next message in the conversation.
+        #
+        # The Messages API can be used for either single queries or stateless multi-turn
+        # conversations.
+        #
+        # Learn more about the Messages API in our [user guide](/en/docs/initial-setup)
+        #
+        # @overload create(max_tokens:, messages:, model:, metadata: nil, stop_sequences: nil, system_: nil, temperature: nil, thinking: nil, tool_choice: nil, tools: nil, top_k: nil, top_p: nil, betas: nil, request_options: {})
+        #
+        # @param max_tokens [Integer]
+        # @param messages [Array<Anthropic::Models::Beta::BetaMessageParam>]
+        # @param model [Symbol, String, Anthropic::Models::Model]
+        # @param metadata [Anthropic::Models::Beta::BetaMetadata]
+        # @param stop_sequences [Array<String>]
+        # @param system_ [String, Array<Anthropic::Models::Beta::BetaTextBlockParam>]
+        # @param temperature [Float]
+        # @param thinking [Anthropic::Models::Beta::BetaThinkingConfigEnabled, Anthropic::Models::Beta::BetaThinkingConfigDisabled]
+        # @param tool_choice [Anthropic::Models::Beta::BetaToolChoiceAuto, Anthropic::Models::Beta::BetaToolChoiceAny, Anthropic::Models::Beta::BetaToolChoiceTool, Anthropic::Models::Beta::BetaToolChoiceNone]
+        # @param tools [Array<Anthropic::Models::Beta::BetaTool, Anthropic::Models::Beta::BetaToolComputerUse20241022, Anthropic::Models::Beta::BetaToolBash20241022, Anthropic::Models::Beta::BetaToolTextEditor20241022, Anthropic::Models::Beta::BetaToolComputerUse20250124, Anthropic::Models::Beta::BetaToolBash20250124, Anthropic::Models::Beta::BetaToolTextEditor20250124>]
+        # @param top_k [Integer]
+        # @param top_p [Float]
+        # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>]
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Models::Beta::BetaMessage]
+        #
+        # @see Anthropic::Models::Beta::MessageCreateParams
+        def create(params)
+          parsed, options = Anthropic::Models::Beta::MessageCreateParams.dump_request(params)
+          if parsed[:stream]
+            message = "Please use `#stream_raw` for the streaming use case."
+            raise ArgumentError.new(message)
+          end
+          header_params = {betas: "anthropic-beta"}
+          @client.request(
+            method: :post,
+            path: "v1/messages?beta=true",
+            headers: parsed.slice(*header_params.keys).transform_keys(header_params),
+            body: parsed.except(*header_params.keys),
+            model: Anthropic::Models::Beta::BetaMessage,
+            options: options
+          )
+        end
+
+        def stream
+          raise NotImplementedError.new("higher level helpers are coming soon!")
+        end
+
+        # See {Anthropic::Resources::Beta::Messages#create} for non-streaming counterpart.
+        #
+        # Send a structured list of input messages with text and/or image content, and the
+        # model will generate the next message in the conversation.
+        #
+        # The Messages API can be used for either single queries or stateless multi-turn
+        # conversations.
+        #
+        # Learn more about the Messages API in our [user guide](/en/docs/initial-setup)
+        #
+        # @overload stream_raw(max_tokens:, messages:, model:, metadata: nil, stop_sequences: nil, system_: nil, temperature: nil, thinking: nil, tool_choice: nil, tools: nil, top_k: nil, top_p: nil, betas: nil, request_options: {})
+        #
+        # @param max_tokens [Integer]
+        # @param messages [Array<Anthropic::Models::Beta::BetaMessageParam>]
+        # @param model [Symbol, String, Anthropic::Models::Model]
+        # @param metadata [Anthropic::Models::Beta::BetaMetadata]
+        # @param stop_sequences [Array<String>]
+        # @param system_ [String, Array<Anthropic::Models::Beta::BetaTextBlockParam>]
+        # @param temperature [Float]
+        # @param thinking [Anthropic::Models::Beta::BetaThinkingConfigEnabled, Anthropic::Models::Beta::BetaThinkingConfigDisabled]
+        # @param tool_choice [Anthropic::Models::Beta::BetaToolChoiceAuto, Anthropic::Models::Beta::BetaToolChoiceAny, Anthropic::Models::Beta::BetaToolChoiceTool, Anthropic::Models::Beta::BetaToolChoiceNone]
+        # @param tools [Array<Anthropic::Models::Beta::BetaTool, Anthropic::Models::Beta::BetaToolComputerUse20241022, Anthropic::Models::Beta::BetaToolBash20241022, Anthropic::Models::Beta::BetaToolTextEditor20241022, Anthropic::Models::Beta::BetaToolComputerUse20250124, Anthropic::Models::Beta::BetaToolBash20250124, Anthropic::Models::Beta::BetaToolTextEditor20250124>]
+        # @param top_k [Integer]
+        # @param top_p [Float]
+        # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>]
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Internal::Stream<Anthropic::Models::Beta::BetaRawMessageStartEvent, Anthropic::Models::Beta::BetaRawMessageDeltaEvent, Anthropic::Models::Beta::BetaRawMessageStopEvent, Anthropic::Models::Beta::BetaRawContentBlockStartEvent, Anthropic::Models::Beta::BetaRawContentBlockDeltaEvent, Anthropic::Models::Beta::BetaRawContentBlockStopEvent>]
+        #
+        # @see Anthropic::Models::Beta::MessageCreateParams
+        def stream_raw(params)
+          parsed, options = Anthropic::Models::Beta::MessageCreateParams.dump_request(params)
+          unless parsed.fetch(:stream, true)
+            message = "Please use `#create` for the non-streaming use case."
+            raise ArgumentError.new(message)
+          end
+          parsed.store(:stream, true)
+          header_params = {betas: "anthropic-beta"}
+          @client.request(
+            method: :post,
+            path: "v1/messages?beta=true",
+            headers: {
+              "accept" => "text/event-stream",
+              **parsed.slice(*header_params.keys)
+            }.transform_keys(header_params),
+            body: parsed.except(*header_params.keys),
+            stream: Anthropic::Internal::Stream,
+            model: Anthropic::Models::Beta::BetaRawMessageStreamEvent,
+            options: options
+          )
+        end
+
+        # Count the number of tokens in a Message.
+        #
+        # The Token Count API can be used to count the number of tokens in a Message,
+        # including tools, images, and documents, without creating it.
+        #
+        # Learn more about token counting in our
+        # [user guide](/en/docs/build-with-claude/token-counting)
+        #
+        # @overload count_tokens(messages:, model:, system_: nil, thinking: nil, tool_choice: nil, tools: nil, betas: nil, request_options: {})
+        #
+        # @param messages [Array<Anthropic::Models::Beta::BetaMessageParam>]
+        # @param model [Symbol, String, Anthropic::Models::Model]
+        # @param system_ [String, Array<Anthropic::Models::Beta::BetaTextBlockParam>]
+        # @param thinking [Anthropic::Models::Beta::BetaThinkingConfigEnabled, Anthropic::Models::Beta::BetaThinkingConfigDisabled]
+        # @param tool_choice [Anthropic::Models::Beta::BetaToolChoiceAuto, Anthropic::Models::Beta::BetaToolChoiceAny, Anthropic::Models::Beta::BetaToolChoiceTool, Anthropic::Models::Beta::BetaToolChoiceNone]
+        # @param tools [Array<Anthropic::Models::Beta::BetaTool, Anthropic::Models::Beta::BetaToolComputerUse20241022, Anthropic::Models::Beta::BetaToolBash20241022, Anthropic::Models::Beta::BetaToolTextEditor20241022, Anthropic::Models::Beta::BetaToolComputerUse20250124, Anthropic::Models::Beta::BetaToolBash20250124, Anthropic::Models::Beta::BetaToolTextEditor20250124>]
+        # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>]
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Models::Beta::BetaMessageTokensCount]
+        #
+        # @see Anthropic::Models::Beta::MessageCountTokensParams
+        def count_tokens(params)
+          parsed, options = Anthropic::Models::Beta::MessageCountTokensParams.dump_request(params)
+          header_params = {betas: "anthropic-beta"}
+          @client.request(
+            method: :post,
+            path: "v1/messages/count_tokens?beta=true",
+            headers: parsed.slice(*header_params.keys).transform_keys(header_params),
+            body: parsed.except(*header_params.keys),
+            model: Anthropic::Models::Beta::BetaMessageTokensCount,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Anthropic::Client]
+        def initialize(client:)
+          @client = client
+          @batches = Anthropic::Resources::Beta::Messages::Batches.new(client: client)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Resources
+    class Beta
+      class Models
+        # Get a specific model.
+        #
+        # The Models API response can be used to determine information about a specific
+        # model or resolve a model alias to a model ID.
+        #
+        # @overload retrieve(model_id, request_options: {})
+        #
+        # @param model_id [String]
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Models::Beta::BetaModelInfo]
+        #
+        # @see Anthropic::Models::Beta::ModelRetrieveParams
+        def retrieve(model_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["v1/models/%1$s?beta=true", model_id],
+            model: Anthropic::Models::Beta::BetaModelInfo,
+            options: params[:request_options]
+          )
+        end
+
+        # List available models.
+        #
+        # The Models API response can be used to determine which models are available for
+        # use in the API. More recently released models are listed first.
+        #
+        # @overload list(after_id: nil, before_id: nil, limit: nil, request_options: {})
+        #
+        # @param after_id [String]
+        # @param before_id [String]
+        # @param limit [Integer]
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Internal::Page<Anthropic::Models::Beta::BetaModelInfo>]
+        #
+        # @see Anthropic::Models::Beta::ModelListParams
+        def list(params = {})
+          parsed, options = Anthropic::Models::Beta::ModelListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "v1/models?beta=true",
+            query: parsed,
+            page: Anthropic::Internal::Page,
+            model: Anthropic::Models::Beta::BetaModelInfo,
+            options: options
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Anthropic::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/resources/beta.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Resources
+    class Beta
+      # @return [Anthropic::Resources::Beta::Models]
+      attr_reader :models
+
+      # @return [Anthropic::Resources::Beta::Messages]
+      attr_reader :messages
+
+      # @api private
+      #
+      # @param client [Anthropic::Client]
+      def initialize(client:)
+        @client = client
+        @models = Anthropic::Resources::Beta::Models.new(client: client)
+        @messages = Anthropic::Resources::Beta::Messages.new(client: client)
+      end
+    end
+  end
+end