anthropic 0.4.1 → 1.1.0

data/lib/anthropic/resources/completions.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Resources
+    class Completions
+      # See {Anthropic::Resources::Completions#create_streaming} for streaming
+      # counterpart.
+      #
+      # Some parameter documentations has been truncated, see
+      # {Anthropic::Models::CompletionCreateParams} for more details.
+      #
+      # [Legacy] Create a Text Completion.
+      #
+      # The Text Completions API is a legacy API. We recommend using the
+      # [Messages API](https://docs.anthropic.com/en/api/messages) going forward.
+      #
+      # Future models and features will not be compatible with Text Completions. See our
+      # [migration guide](https://docs.anthropic.com/en/api/migrating-from-text-completions-to-messages)
+      # for guidance in migrating from Text Completions to Messages.
+      #
+      # @overload create(max_tokens_to_sample:, model:, prompt:, metadata: nil, stop_sequences: nil, temperature: nil, top_k: nil, top_p: nil, betas: nil, request_options: {})
+      #
+      # @param max_tokens_to_sample [Integer] Body param: The maximum number of tokens to generate before stopping.
+      #
+      # @param model [Symbol, String, Anthropic::Models::Model] Body param: The model that will complete your prompt.\n\nSee [models](https://do
+      #
+      # @param prompt [String] Body param: The prompt that you want Claude to complete.
+      #
+      # @param metadata [Anthropic::Models::Metadata] Body param: An object describing metadata about the request.
+      #
+      # @param stop_sequences [Array<String>] Body param: Sequences that will cause the model to stop generating.
+      #
+      # @param temperature [Float] Body param: Amount of randomness injected into the response.
+      #
+      # @param top_k [Integer] Body param: Only sample from the top K options for each subsequent token.
+      #
+      # @param top_p [Float] Body param: Use nucleus sampling.
+      #
+      # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>] Header param: Optional header to specify the beta version(s) you want to use.
+      #
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Models::Completion]
+      #
+      # @see Anthropic::Models::CompletionCreateParams
+      def create(params)
+        parsed, options = Anthropic::CompletionCreateParams.dump_request(params)
+        if parsed[:stream]
+          message = "Please use `#create_streaming` for the streaming use case."
+          raise ArgumentError.new(message)
+        end
+        header_params = {betas: "anthropic-beta"}
+        @client.request(
+          method: :post,
+          path: "v1/complete",
+          headers: parsed.slice(*header_params.keys).transform_keys(header_params),
+          body: parsed.except(*header_params.keys),
+          model: Anthropic::Completion,
+          options: {timeout: 600, **options}
+        )
+      end
+
+      # See {Anthropic::Resources::Completions#create} for non-streaming counterpart.
+      #
+      # Some parameter documentations has been truncated, see
+      # {Anthropic::Models::CompletionCreateParams} for more details.
+      #
+      # [Legacy] Create a Text Completion.
+      #
+      # The Text Completions API is a legacy API. We recommend using the
+      # [Messages API](https://docs.anthropic.com/en/api/messages) going forward.
+      #
+      # Future models and features will not be compatible with Text Completions. See our
+      # [migration guide](https://docs.anthropic.com/en/api/migrating-from-text-completions-to-messages)
+      # for guidance in migrating from Text Completions to Messages.
+      #
+      # @overload create_streaming(max_tokens_to_sample:, model:, prompt:, metadata: nil, stop_sequences: nil, temperature: nil, top_k: nil, top_p: nil, betas: nil, request_options: {})
+      #
+      # @param max_tokens_to_sample [Integer] Body param: The maximum number of tokens to generate before stopping.
+      #
+      # @param model [Symbol, String, Anthropic::Models::Model] Body param: The model that will complete your prompt.\n\nSee [models](https://do
+      #
+      # @param prompt [String] Body param: The prompt that you want Claude to complete.
+      #
+      # @param metadata [Anthropic::Models::Metadata] Body param: An object describing metadata about the request.
+      #
+      # @param stop_sequences [Array<String>] Body param: Sequences that will cause the model to stop generating.
+      #
+      # @param temperature [Float] Body param: Amount of randomness injected into the response.
+      #
+      # @param top_k [Integer] Body param: Only sample from the top K options for each subsequent token.
+      #
+      # @param top_p [Float] Body param: Use nucleus sampling.
+      #
+      # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>] Header param: Optional header to specify the beta version(s) you want to use.
+      #
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Internal::Stream<Anthropic::Models::Completion>]
+      #
+      # @see Anthropic::Models::CompletionCreateParams
+      def create_streaming(params)
+        parsed, options = Anthropic::CompletionCreateParams.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/complete",
+          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::Completion,
+          options: {timeout: 600, **options}
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Anthropic::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

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

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Resources
+    class Messages
+      class Batches
+        # Some parameter documentations has been truncated, see
+        # {Anthropic::Models::Messages::BatchCreateParams} for more details.
+        #
+        # 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:, request_options: {})
+        #
+        # @param requests [Array<Anthropic::Models::Messages::BatchCreateParams::Request>] List of requests for prompt completion. Each is an individual request to create
+        #
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Models::Messages::MessageBatch]
+        #
+        # @see Anthropic::Models::Messages::BatchCreateParams
+        def create(params)
+          parsed, options = Anthropic::Messages::BatchCreateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "v1/messages/batches",
+            body: parsed,
+            model: Anthropic::Messages::MessageBatch,
+            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, request_options: {})
+        #
+        # @param message_batch_id [String] ID of the Message Batch.
+        #
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Models::Messages::MessageBatch]
+        #
+        # @see Anthropic::Models::Messages::BatchRetrieveParams
+        def retrieve(message_batch_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["v1/messages/batches/%1$s", message_batch_id],
+            model: Anthropic::Messages::MessageBatch,
+            options: params[:request_options]
+          )
+        end
+
+        # Some parameter documentations has been truncated, see
+        # {Anthropic::Models::Messages::BatchListParams} for more details.
+        #
+        # 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, request_options: {})
+        #
+        # @param after_id [String] ID of the object to use as a cursor for pagination. When provided, returns the p
+        #
+        # @param before_id [String] ID of the object to use as a cursor for pagination. When provided, returns the p
+        #
+        # @param limit [Integer] Number of items to return per page.
+        #
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Internal::Page<Anthropic::Models::Messages::MessageBatch>]
+        #
+        # @see Anthropic::Models::Messages::BatchListParams
+        def list(params = {})
+          parsed, options = Anthropic::Messages::BatchListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "v1/messages/batches",
+            query: parsed,
+            page: Anthropic::Internal::Page,
+            model: Anthropic::Messages::MessageBatch,
+            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, request_options: {})
+        #
+        # @param message_batch_id [String] ID of the Message Batch.
+        #
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Models::Messages::DeletedMessageBatch]
+        #
+        # @see Anthropic::Models::Messages::BatchDeleteParams
+        def delete(message_batch_id, params = {})
+          @client.request(
+            method: :delete,
+            path: ["v1/messages/batches/%1$s", message_batch_id],
+            model: Anthropic::Messages::DeletedMessageBatch,
+            options: params[:request_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, request_options: {})
+        #
+        # @param message_batch_id [String] ID of the Message Batch.
+        #
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Models::Messages::MessageBatch]
+        #
+        # @see Anthropic::Models::Messages::BatchCancelParams
+        def cancel(message_batch_id, params = {})
+          @client.request(
+            method: :post,
+            path: ["v1/messages/batches/%1$s/cancel", message_batch_id],
+            model: Anthropic::Messages::MessageBatch,
+            options: params[:request_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, request_options: {})
+        #
+        # @param message_batch_id [String] ID of the Message Batch.
+        #
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Internal::JsonLStream<Anthropic::Models::Messages::MessageBatchIndividualResponse>]
+        #
+        # @see Anthropic::Models::Messages::BatchResultsParams
+        def results_streaming(message_batch_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["v1/messages/batches/%1$s/results", message_batch_id],
+            headers: {"accept" => "application/x-jsonl"},
+            stream: Anthropic::Internal::JsonLStream,
+            model: Anthropic::Messages::MessageBatchIndividualResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Anthropic::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/resources/messages.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Resources
+    class Messages
+      # @return [Anthropic::Resources::Messages::Batches]
+      attr_reader :batches
+
+      # See {Anthropic::Resources::Messages#stream_raw} for streaming counterpart.
+      #
+      # Some parameter documentations has been truncated, see
+      # {Anthropic::Models::MessageCreateParams} for more details.
+      #
+      # 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, service_tier: nil, stop_sequences: nil, system_: nil, temperature: nil, thinking: nil, tool_choice: nil, tools: nil, top_k: nil, top_p: nil, request_options: {})
+      #
+      # @param max_tokens [Integer] The maximum number of tokens to generate before stopping.
+      #
+      # @param messages [Array<Anthropic::Models::MessageParam>] Input messages.
+      #
+      # @param model [Symbol, String, Anthropic::Models::Model] The model that will complete your prompt.\n\nSee [models](https://docs.anthropic
+      #
+      # @param metadata [Anthropic::Models::Metadata] An object describing metadata about the request.
+      #
+      # @param service_tier [Symbol, Anthropic::Models::MessageCreateParams::ServiceTier] Determines whether to use priority capacity (if available) or standard capacity
+      #
+      # @param stop_sequences [Array<String>] Custom text sequences that will cause the model to stop generating.
+      #
+      # @param system_ [String, Array<Anthropic::Models::TextBlockParam>] System prompt.
+      #
+      # @param temperature [Float] Amount of randomness injected into the response.
+      #
+      # @param thinking [Anthropic::Models::ThinkingConfigEnabled, Anthropic::Models::ThinkingConfigDisabled] Configuration for enabling Claude's extended thinking.
+      #
+      # @param tool_choice [Anthropic::Models::ToolChoiceAuto, Anthropic::Models::ToolChoiceAny, Anthropic::Models::ToolChoiceTool, Anthropic::Models::ToolChoiceNone] How the model should use the provided tools. The model can use a specific tool,
+      #
+      # @param tools [Array<Anthropic::Models::Tool, Anthropic::Models::ToolBash20250124, Anthropic::Models::ToolTextEditor20250124, Anthropic::Models::WebSearchTool20250305>] Definitions of tools that the model may use.
+      #
+      # @param top_k [Integer] Only sample from the top K options for each subsequent token.
+      #
+      # @param top_p [Float] Use nucleus sampling.
+      #
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Models::Message]
+      #
+      # @see Anthropic::Models::MessageCreateParams
+      def create(params)
+        parsed, options = Anthropic::MessageCreateParams.dump_request(params)
+        if parsed[:stream]
+          message = "Please use `#stream_raw` for the streaming use case."
+          raise ArgumentError.new(message)
+        end
+
+        if options.empty? && @client.timeout == Anthropic::Client::DEFAULT_TIMEOUT_IN_SECONDS
+          model = parsed[:model].to_sym
+          max_tokens = parsed[:max_tokens].to_i
+          timeout = @client.calculate_nonstreaming_timeout(
+            max_tokens,
+            Anthropic::Client::MODEL_NONSTREAMING_TOKENS[model]
+          )
+          options = {timeout: timeout}
+        else
+          options = {timeout: 600, **options}
+        end
+
+        @client.request(
+          method: :post,
+          path: "v1/messages",
+          body: parsed,
+          model: Anthropic::Message,
+          options: options
+        )
+      end
+
+      def stream
+        raise NotImplementedError.new("higher level helpers are coming soon!")
+      end
+
+      # See {Anthropic::Resources::Messages#create} for non-streaming counterpart.
+      #
+      # Some parameter documentations has been truncated, see
+      # {Anthropic::Models::MessageCreateParams} for more details.
+      #
+      # 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, service_tier: nil, stop_sequences: nil, system_: nil, temperature: nil, thinking: nil, tool_choice: nil, tools: nil, top_k: nil, top_p: nil, request_options: {})
+      #
+      # @param max_tokens [Integer] The maximum number of tokens to generate before stopping.
+      #
+      # @param messages [Array<Anthropic::Models::MessageParam>] Input messages.
+      #
+      # @param model [Symbol, String, Anthropic::Models::Model] The model that will complete your prompt.\n\nSee [models](https://docs.anthropic
+      #
+      # @param metadata [Anthropic::Models::Metadata] An object describing metadata about the request.
+      #
+      # @param service_tier [Symbol, Anthropic::Models::MessageCreateParams::ServiceTier] Determines whether to use priority capacity (if available) or standard capacity
+      #
+      # @param stop_sequences [Array<String>] Custom text sequences that will cause the model to stop generating.
+      #
+      # @param system_ [String, Array<Anthropic::Models::TextBlockParam>] System prompt.
+      #
+      # @param temperature [Float] Amount of randomness injected into the response.
+      #
+      # @param thinking [Anthropic::Models::ThinkingConfigEnabled, Anthropic::Models::ThinkingConfigDisabled] Configuration for enabling Claude's extended thinking.
+      #
+      # @param tool_choice [Anthropic::Models::ToolChoiceAuto, Anthropic::Models::ToolChoiceAny, Anthropic::Models::ToolChoiceTool, Anthropic::Models::ToolChoiceNone] How the model should use the provided tools. The model can use a specific tool,
+      #
+      # @param tools [Array<Anthropic::Models::Tool, Anthropic::Models::ToolBash20250124, Anthropic::Models::ToolTextEditor20250124, Anthropic::Models::WebSearchTool20250305>] Definitions of tools that the model may use.
+      #
+      # @param top_k [Integer] Only sample from the top K options for each subsequent token.
+      #
+      # @param top_p [Float] Use nucleus sampling.
+      #
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Internal::Stream<Anthropic::Models::RawMessageStartEvent, Anthropic::Models::RawMessageDeltaEvent, Anthropic::Models::RawMessageStopEvent, Anthropic::Models::RawContentBlockStartEvent, Anthropic::Models::RawContentBlockDeltaEvent, Anthropic::Models::RawContentBlockStopEvent>]
+      #
+      # @see Anthropic::Models::MessageCreateParams
+      def stream_raw(params)
+        parsed, options = Anthropic::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)
+        @client.request(
+          method: :post,
+          path: "v1/messages",
+          headers: {"accept" => "text/event-stream"},
+          body: parsed,
+          stream: Anthropic::Internal::Stream,
+          model: Anthropic::RawMessageStreamEvent,
+          options: {timeout: 600, **options}
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Anthropic::Models::MessageCountTokensParams} for more details.
+      #
+      # 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, request_options: {})
+      #
+      # @param messages [Array<Anthropic::Models::MessageParam>] Input messages.
+      #
+      # @param model [Symbol, String, Anthropic::Models::Model] The model that will complete your prompt.\n\nSee [models](https://docs.anthropic
+      #
+      # @param system_ [String, Array<Anthropic::Models::TextBlockParam>] System prompt.
+      #
+      # @param thinking [Anthropic::Models::ThinkingConfigEnabled, Anthropic::Models::ThinkingConfigDisabled] Configuration for enabling Claude's extended thinking.
+      #
+      # @param tool_choice [Anthropic::Models::ToolChoiceAuto, Anthropic::Models::ToolChoiceAny, Anthropic::Models::ToolChoiceTool, Anthropic::Models::ToolChoiceNone] How the model should use the provided tools. The model can use a specific tool,
+      #
+      # @param tools [Array<Anthropic::Models::Tool, Anthropic::Models::ToolBash20250124, Anthropic::Models::ToolTextEditor20250124, Anthropic::Models::WebSearchTool20250305>] Definitions of tools that the model may use.
+      #
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Models::MessageTokensCount]
+      #
+      # @see Anthropic::Models::MessageCountTokensParams
+      def count_tokens(params)
+        parsed, options = Anthropic::MessageCountTokensParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v1/messages/count_tokens",
+          body: parsed,
+          model: Anthropic::MessageTokensCount,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Anthropic::Client]
+      def initialize(client:)
+        @client = client
+        @batches = Anthropic::Resources::Messages::Batches.new(client: client)
+      end
+    end
+  end
+end

data/lib/anthropic/resources/models.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Resources
+    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, betas: nil, request_options: {})
+      #
+      # @param model_id [String] Model identifier or alias.
+      #
+      # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>] Optional header to specify the beta version(s) you want to use.
+      #
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Models::ModelInfo]
+      #
+      # @see Anthropic::Models::ModelRetrieveParams
+      def retrieve(model_id, params = {})
+        parsed, options = Anthropic::ModelRetrieveParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: ["v1/models/%1$s", model_id],
+          headers: parsed.transform_keys(betas: "anthropic-beta"),
+          model: Anthropic::ModelInfo,
+          options: options
+        )
+      end
+
+      # Some parameter documentations has been truncated, see
+      # {Anthropic::Models::ModelListParams} for more details.
+      #
+      # 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, betas: nil, request_options: {})
+      #
+      # @param after_id [String] Query param: ID of the object to use as a cursor for pagination. When provided,
+      #
+      # @param before_id [String] Query param: ID of the object to use as a cursor for pagination. When provided,
+      #
+      # @param limit [Integer] Query param: Number of items to return per page.
+      #
+      # @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>] Header param: Optional header to specify the beta version(s) you want to use.
+      #
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Internal::Page<Anthropic::Models::ModelInfo>]
+      #
+      # @see Anthropic::Models::ModelListParams
+      def list(params = {})
+        parsed, options = Anthropic::ModelListParams.dump_request(params)
+        query_params = [:after_id, :before_id, :limit]
+        @client.request(
+          method: :get,
+          path: "v1/models",
+          query: parsed.slice(*query_params),
+          headers: parsed.except(*query_params).transform_keys(betas: "anthropic-beta"),
+          page: Anthropic::Internal::Page,
+          model: Anthropic::ModelInfo,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Anthropic::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/anthropic/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Anthropic
-  VERSION = "0.4.1".freeze
+  VERSION = "1.1.0"
 end

data/lib/anthropic/vertex.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Anthropic
+  VertexClient = Anthropic::Helpers::Vertex::Client
+end