anthropic 0.4.0 → 1.0.0

data/rbi/anthropic/resources/beta/models.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+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.
+        sig do
+          params(
+            model_id: String,
+            betas: T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)],
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(Anthropic::Beta::BetaModelInfo)
+        end
+        def retrieve(
+          # Model identifier or alias.
+          model_id,
+          # Optional header to specify the beta version(s) you want to use.
+          betas: nil,
+          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.
+        sig do
+          params(
+            after_id: String,
+            before_id: String,
+            limit: Integer,
+            betas: T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)],
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(Anthropic::Internal::Page[Anthropic::Beta::BetaModelInfo])
+        end
+        def list(
+          # Query param: ID of the object to use as a cursor for pagination. When provided,
+          # returns the page of results immediately after this object.
+          after_id: nil,
+          # Query param: ID of the object to use as a cursor for pagination. When provided,
+          # returns the page of results immediately before this object.
+          before_id: nil,
+          # Query param: Number of items to return per page.
+          #
+          # Defaults to `20`. Ranges from `1` to `1000`.
+          limit: nil,
+          # Header param: Optional header to specify the beta version(s) you want to use.
+          betas: nil,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Anthropic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/resources/beta.rbi

@@ -0,0 +1,18 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      sig { returns(Anthropic::Resources::Beta::Models) }
+      attr_reader :models
+
+      sig { returns(Anthropic::Resources::Beta::Messages) }
+      attr_reader :messages
+
+      # @api private
+      sig { params(client: Anthropic::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/anthropic/resources/completions.rbi

@@ -0,0 +1,199 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Completions
+      # See {Anthropic::Resources::Completions#create_streaming} for streaming
+      # counterpart.
+      #
+      # [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.
+      sig do
+        params(
+          max_tokens_to_sample: Integer,
+          model: T.any(Anthropic::Model::OrSymbol, String),
+          prompt: String,
+          metadata: Anthropic::Metadata::OrHash,
+          stop_sequences: T::Array[String],
+          temperature: Float,
+          top_k: Integer,
+          top_p: Float,
+          betas: T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)],
+          stream: T.noreturn,
+          request_options: Anthropic::RequestOptions::OrHash
+        ).returns(Anthropic::Completion)
+      end
+      def create(
+        # Body param: The maximum number of tokens to generate before stopping.
+        #
+        # Note that our models may stop _before_ reaching this maximum. This parameter
+        # only specifies the absolute maximum number of tokens to generate.
+        max_tokens_to_sample:,
+        # Body param: The model that will complete your prompt.\n\nSee
+        # [models](https://docs.anthropic.com/en/docs/models-overview) for additional
+        # details and options.
+        model:,
+        # Body param: The prompt that you want Claude to complete.
+        #
+        # For proper response generation you will need to format your prompt using
+        # alternating `\n\nHuman:` and `\n\nAssistant:` conversational turns. For example:
+        #
+        # ```
+        # "\n\nHuman: {userQuestion}\n\nAssistant:"
+        # ```
+        #
+        # See [prompt validation](https://docs.anthropic.com/en/api/prompt-validation) and
+        # our guide to
+        # [prompt design](https://docs.anthropic.com/en/docs/intro-to-prompting) for more
+        # details.
+        prompt:,
+        # Body param: An object describing metadata about the request.
+        metadata: nil,
+        # Body param: Sequences that will cause the model to stop generating.
+        #
+        # Our models stop on `"\n\nHuman:"`, and may include additional built-in stop
+        # sequences in the future. By providing the stop_sequences parameter, you may
+        # include additional strings that will cause the model to stop generating.
+        stop_sequences: nil,
+        # Body param: Amount of randomness injected into the response.
+        #
+        # Defaults to `1.0`. Ranges from `0.0` to `1.0`. Use `temperature` closer to `0.0`
+        # for analytical / multiple choice, and closer to `1.0` for creative and
+        # generative tasks.
+        #
+        # Note that even with `temperature` of `0.0`, the results will not be fully
+        # deterministic.
+        temperature: nil,
+        # Body param: Only sample from the top K options for each subsequent token.
+        #
+        # Used to remove "long tail" low probability responses.
+        # [Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
+        #
+        # Recommended for advanced use cases only. You usually only need to use
+        # `temperature`.
+        top_k: nil,
+        # Body param: Use nucleus sampling.
+        #
+        # In nucleus sampling, we compute the cumulative distribution over all the options
+        # for each subsequent token in decreasing probability order and cut it off once it
+        # reaches a particular probability specified by `top_p`. You should either alter
+        # `temperature` or `top_p`, but not both.
+        #
+        # Recommended for advanced use cases only. You usually only need to use
+        # `temperature`.
+        top_p: nil,
+        # Header param: Optional header to specify the beta version(s) you want to use.
+        betas: nil,
+        # There is no need to provide `stream:`. Instead, use `#create_streaming` or
+        # `#create` for streaming and non-streaming use cases, respectively.
+        stream: false,
+        request_options: {}
+      )
+      end
+
+      # See {Anthropic::Resources::Completions#create} for non-streaming counterpart.
+      #
+      # [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.
+      sig do
+        params(
+          max_tokens_to_sample: Integer,
+          model: T.any(Anthropic::Model::OrSymbol, String),
+          prompt: String,
+          metadata: Anthropic::Metadata::OrHash,
+          stop_sequences: T::Array[String],
+          temperature: Float,
+          top_k: Integer,
+          top_p: Float,
+          betas: T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)],
+          stream: T.noreturn,
+          request_options: Anthropic::RequestOptions::OrHash
+        ).returns(Anthropic::Internal::Stream[Anthropic::Completion])
+      end
+      def create_streaming(
+        # Body param: The maximum number of tokens to generate before stopping.
+        #
+        # Note that our models may stop _before_ reaching this maximum. This parameter
+        # only specifies the absolute maximum number of tokens to generate.
+        max_tokens_to_sample:,
+        # Body param: The model that will complete your prompt.\n\nSee
+        # [models](https://docs.anthropic.com/en/docs/models-overview) for additional
+        # details and options.
+        model:,
+        # Body param: The prompt that you want Claude to complete.
+        #
+        # For proper response generation you will need to format your prompt using
+        # alternating `\n\nHuman:` and `\n\nAssistant:` conversational turns. For example:
+        #
+        # ```
+        # "\n\nHuman: {userQuestion}\n\nAssistant:"
+        # ```
+        #
+        # See [prompt validation](https://docs.anthropic.com/en/api/prompt-validation) and
+        # our guide to
+        # [prompt design](https://docs.anthropic.com/en/docs/intro-to-prompting) for more
+        # details.
+        prompt:,
+        # Body param: An object describing metadata about the request.
+        metadata: nil,
+        # Body param: Sequences that will cause the model to stop generating.
+        #
+        # Our models stop on `"\n\nHuman:"`, and may include additional built-in stop
+        # sequences in the future. By providing the stop_sequences parameter, you may
+        # include additional strings that will cause the model to stop generating.
+        stop_sequences: nil,
+        # Body param: Amount of randomness injected into the response.
+        #
+        # Defaults to `1.0`. Ranges from `0.0` to `1.0`. Use `temperature` closer to `0.0`
+        # for analytical / multiple choice, and closer to `1.0` for creative and
+        # generative tasks.
+        #
+        # Note that even with `temperature` of `0.0`, the results will not be fully
+        # deterministic.
+        temperature: nil,
+        # Body param: Only sample from the top K options for each subsequent token.
+        #
+        # Used to remove "long tail" low probability responses.
+        # [Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
+        #
+        # Recommended for advanced use cases only. You usually only need to use
+        # `temperature`.
+        top_k: nil,
+        # Body param: Use nucleus sampling.
+        #
+        # In nucleus sampling, we compute the cumulative distribution over all the options
+        # for each subsequent token in decreasing probability order and cut it off once it
+        # reaches a particular probability specified by `top_p`. You should either alter
+        # `temperature` or `top_p`, but not both.
+        #
+        # Recommended for advanced use cases only. You usually only need to use
+        # `temperature`.
+        top_p: nil,
+        # Header param: Optional header to specify the beta version(s) you want to use.
+        betas: nil,
+        # There is no need to provide `stream:`. Instead, use `#create_streaming` or
+        # `#create` for streaming and non-streaming use cases, respectively.
+        stream: true,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: Anthropic::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/anthropic/resources/messages/batches.rbi

@@ -0,0 +1,156 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    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)
+        sig do
+          params(
+            requests:
+              T::Array[Anthropic::Messages::BatchCreateParams::Request::OrHash],
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(Anthropic::Messages::MessageBatch)
+        end
+        def create(
+          # List of requests for prompt completion. Each is an individual request to create
+          # a Message.
+          requests:,
+          request_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)
+        sig do
+          params(
+            message_batch_id: String,
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(Anthropic::Messages::MessageBatch)
+        end
+        def retrieve(
+          # ID of the Message Batch.
+          message_batch_id,
+          request_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)
+        sig do
+          params(
+            after_id: String,
+            before_id: String,
+            limit: Integer,
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(
+            Anthropic::Internal::Page[Anthropic::Messages::MessageBatch]
+          )
+        end
+        def list(
+          # ID of the object to use as a cursor for pagination. When provided, returns the
+          # page of results immediately after this object.
+          after_id: nil,
+          # ID of the object to use as a cursor for pagination. When provided, returns the
+          # page of results immediately before this object.
+          before_id: nil,
+          # Number of items to return per page.
+          #
+          # Defaults to `20`. Ranges from `1` to `1000`.
+          limit: nil,
+          request_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)
+        sig do
+          params(
+            message_batch_id: String,
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(Anthropic::Messages::DeletedMessageBatch)
+        end
+        def delete(
+          # ID of the Message Batch.
+          message_batch_id,
+          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)
+        sig do
+          params(
+            message_batch_id: String,
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(Anthropic::Messages::MessageBatch)
+        end
+        def cancel(
+          # ID of the Message Batch.
+          message_batch_id,
+          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)
+        sig do
+          params(
+            message_batch_id: String,
+            request_options: Anthropic::RequestOptions::OrHash
+          ).returns(
+            Anthropic::Internal::JsonLStream[
+              Anthropic::Messages::MessageBatchIndividualResponse
+            ]
+          )
+        end
+        def results_streaming(
+          # ID of the Message Batch.
+          message_batch_id,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: Anthropic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end