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

data/rbi/lib/anthropic/request_options.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+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
+    sig { params(opts: T.any(T.self_type, T::Hash[Symbol, T.anything])).void }
+    def self.validate!(opts); end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])) }
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig { params(values: Anthropic::Internal::AnyHash).returns(T.attached_class) }
+    def self.new(values = {}); end
+  end
+end

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

@@ -0,0 +1,164 @@
+# typed: strong
+
+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)
+          sig do
+            params(
+              requests: T::Array[T.any(Anthropic::Models::Beta::Messages::BatchCreateParams::Request, Anthropic::Internal::AnyHash)],
+              betas: T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)],
+              request_options: T.nilable(T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash))
+            )
+              .returns(Anthropic::Models::Beta::Messages::BetaMessageBatch)
+          end
+          def create(
+            # Body param: List of requests for prompt completion. Each is an individual
+            # request to create a Message.
+            requests:,
+            # Header param: Optional header to specify the beta version(s) you want to use.
+            betas: nil,
+            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,
+              betas: T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)],
+              request_options: T.nilable(T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash))
+            )
+              .returns(Anthropic::Models::Beta::Messages::BetaMessageBatch)
+          end
+          def retrieve(
+            # ID of the Message Batch.
+            message_batch_id,
+            # Optional header to specify the beta version(s) you want to use.
+            betas: nil,
+            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,
+              betas: T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)],
+              request_options: T.nilable(T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash))
+            )
+              .returns(Anthropic::Internal::Page[Anthropic::Models::Beta::Messages::BetaMessageBatch])
+          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
+          # 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,
+              betas: T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)],
+              request_options: T.nilable(T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash))
+            )
+              .returns(Anthropic::Models::Beta::Messages::BetaDeletedMessageBatch)
+          end
+          def delete(
+            # ID of the Message Batch.
+            message_batch_id,
+            # Optional header to specify the beta version(s) you want to use.
+            betas: nil,
+            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,
+              betas: T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)],
+              request_options: T.nilable(T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash))
+            )
+              .returns(Anthropic::Models::Beta::Messages::BetaMessageBatch)
+          end
+          def cancel(
+            # ID of the Message Batch.
+            message_batch_id,
+            # Optional header to specify the beta version(s) you want to use.
+            betas: nil,
+            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,
+              betas: T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)],
+              request_options: T.nilable(T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash))
+            )
+              .returns(
+                Anthropic::Internal::JsonLStream[Anthropic::Models::Beta::Messages::BetaMessageBatchIndividualResponse]
+              )
+          end
+          def results_streaming(
+            # ID of the Message Batch.
+            message_batch_id,
+            # 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
+end