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

data/rbi/lib/anthropic/models/beta/messages/batch_results_params.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Messages
+        class BatchResultsParams < Anthropic::Internal::Type::BaseModel
+          extend Anthropic::Internal::Type::RequestParameters::Converter
+          include Anthropic::Internal::Type::RequestParameters
+
+          # Optional header to specify the beta version(s) you want to use.
+          sig { returns(T.nilable(T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)])) }
+          attr_reader :betas
+
+          sig { params(betas: T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)]).void }
+          attr_writer :betas
+
+          sig do
+            params(
+              betas: T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)],
+              request_options: T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash)
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(betas: nil, request_options: {}); end
+
+          sig do
+            override
+              .returns(
+                {
+                  betas: T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)],
+                  request_options: Anthropic::RequestOptions
+                }
+              )
+          end
+          def to_hash; end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta/messages/batch_retrieve_params.rbi

@@ -0,0 +1,41 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Messages
+        class BatchRetrieveParams < Anthropic::Internal::Type::BaseModel
+          extend Anthropic::Internal::Type::RequestParameters::Converter
+          include Anthropic::Internal::Type::RequestParameters
+
+          # Optional header to specify the beta version(s) you want to use.
+          sig { returns(T.nilable(T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)])) }
+          attr_reader :betas
+
+          sig { params(betas: T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)]).void }
+          attr_writer :betas
+
+          sig do
+            params(
+              betas: T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)],
+              request_options: T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash)
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(betas: nil, request_options: {}); end
+
+          sig do
+            override
+              .returns(
+                {
+                  betas: T::Array[T.any(String, Anthropic::Models::AnthropicBeta::OrSymbol)],
+                  request_options: Anthropic::RequestOptions
+                }
+              )
+          end
+          def to_hash; end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta/messages/beta_deleted_message_batch.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Messages
+        class BetaDeletedMessageBatch < Anthropic::Internal::Type::BaseModel
+          # ID of the Message Batch.
+          sig { returns(String) }
+          attr_accessor :id
+
+          # Deleted object type.
+          #
+          # For Message Batches, this is always `"message_batch_deleted"`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { params(id: String, type: Symbol).returns(T.attached_class) }
+          def self.new(id:, type: :message_batch_deleted); end
+
+          sig { override.returns({id: String, type: Symbol}) }
+          def to_hash; end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta/messages/beta_message_batch.rbi

@@ -0,0 +1,148 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Messages
+        class BetaMessageBatch < Anthropic::Internal::Type::BaseModel
+          # Unique object identifier.
+          #
+          # The format and length of IDs may change over time.
+          sig { returns(String) }
+          attr_accessor :id
+
+          # RFC 3339 datetime string representing the time at which the Message Batch was
+          # archived and its results became unavailable.
+          sig { returns(T.nilable(Time)) }
+          attr_accessor :archived_at
+
+          # RFC 3339 datetime string representing the time at which cancellation was
+          # initiated for the Message Batch. Specified only if cancellation was initiated.
+          sig { returns(T.nilable(Time)) }
+          attr_accessor :cancel_initiated_at
+
+          # RFC 3339 datetime string representing the time at which the Message Batch was
+          # created.
+          sig { returns(Time) }
+          attr_accessor :created_at
+
+          # RFC 3339 datetime string representing the time at which processing for the
+          # Message Batch ended. Specified only once processing ends.
+          #
+          # Processing ends when every request in a Message Batch has either succeeded,
+          # errored, canceled, or expired.
+          sig { returns(T.nilable(Time)) }
+          attr_accessor :ended_at
+
+          # RFC 3339 datetime string representing the time at which the Message Batch will
+          # expire and end processing, which is 24 hours after creation.
+          sig { returns(Time) }
+          attr_accessor :expires_at
+
+          # Processing status of the Message Batch.
+          sig { returns(Anthropic::Models::Beta::Messages::BetaMessageBatch::ProcessingStatus::TaggedSymbol) }
+          attr_accessor :processing_status
+
+          # Tallies requests within the Message Batch, categorized by their status.
+          #
+          # Requests start as `processing` and move to one of the other statuses only once
+          # processing of the entire batch ends. The sum of all values always matches the
+          # total number of requests in the batch.
+          sig { returns(Anthropic::Models::Beta::Messages::BetaMessageBatchRequestCounts) }
+          attr_reader :request_counts
+
+          sig do
+            params(
+              request_counts: T.any(Anthropic::Models::Beta::Messages::BetaMessageBatchRequestCounts, Anthropic::Internal::AnyHash)
+            )
+              .void
+          end
+          attr_writer :request_counts
+
+          # URL to a `.jsonl` file containing the results of the Message Batch requests.
+          # Specified only once processing ends.
+          #
+          # Results in the file are not guaranteed to be in the same order as requests. Use
+          # the `custom_id` field to match results to requests.
+          sig { returns(T.nilable(String)) }
+          attr_accessor :results_url
+
+          # Object type.
+          #
+          # For Message Batches, this is always `"message_batch"`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(
+              id: String,
+              archived_at: T.nilable(Time),
+              cancel_initiated_at: T.nilable(Time),
+              created_at: Time,
+              ended_at: T.nilable(Time),
+              expires_at: Time,
+              processing_status: Anthropic::Models::Beta::Messages::BetaMessageBatch::ProcessingStatus::OrSymbol,
+              request_counts: T.any(Anthropic::Models::Beta::Messages::BetaMessageBatchRequestCounts, Anthropic::Internal::AnyHash),
+              results_url: T.nilable(String),
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+            id:,
+            archived_at:,
+            cancel_initiated_at:,
+            created_at:,
+            ended_at:,
+            expires_at:,
+            processing_status:,
+            request_counts:,
+            results_url:,
+            type: :message_batch
+          ); end
+          sig do
+            override
+              .returns(
+                {
+                  id: String,
+                  archived_at: T.nilable(Time),
+                  cancel_initiated_at: T.nilable(Time),
+                  created_at: Time,
+                  ended_at: T.nilable(Time),
+                  expires_at: Time,
+                  processing_status: Anthropic::Models::Beta::Messages::BetaMessageBatch::ProcessingStatus::TaggedSymbol,
+                  request_counts: Anthropic::Models::Beta::Messages::BetaMessageBatchRequestCounts,
+                  results_url: T.nilable(String),
+                  type: Symbol
+                }
+              )
+          end
+          def to_hash; end
+
+          # Processing status of the Message Batch.
+          module ProcessingStatus
+            extend Anthropic::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias { T.all(Symbol, Anthropic::Models::Beta::Messages::BetaMessageBatch::ProcessingStatus) }
+            OrSymbol =
+              T.type_alias { T.any(Symbol, String, Anthropic::Models::Beta::Messages::BetaMessageBatch::ProcessingStatus::TaggedSymbol) }
+
+            IN_PROGRESS =
+              T.let(:in_progress, Anthropic::Models::Beta::Messages::BetaMessageBatch::ProcessingStatus::TaggedSymbol)
+            CANCELING =
+              T.let(:canceling, Anthropic::Models::Beta::Messages::BetaMessageBatch::ProcessingStatus::TaggedSymbol)
+            ENDED =
+              T.let(:ended, Anthropic::Models::Beta::Messages::BetaMessageBatch::ProcessingStatus::TaggedSymbol)
+
+            sig do
+              override
+                .returns(T::Array[Anthropic::Models::Beta::Messages::BetaMessageBatch::ProcessingStatus::TaggedSymbol])
+            end
+            def self.values; end
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta/messages/beta_message_batch_canceled_result.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Messages
+        class BetaMessageBatchCanceledResult < Anthropic::Internal::Type::BaseModel
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { params(type: Symbol).returns(T.attached_class) }
+          def self.new(type: :canceled); end
+
+          sig { override.returns({type: Symbol}) }
+          def to_hash; end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta/messages/beta_message_batch_errored_result.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Messages
+        class BetaMessageBatchErroredResult < Anthropic::Internal::Type::BaseModel
+          sig { returns(Anthropic::Models::BetaErrorResponse) }
+          attr_reader :error
+
+          sig { params(error: T.any(Anthropic::Models::BetaErrorResponse, Anthropic::Internal::AnyHash)).void }
+          attr_writer :error
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(error: T.any(Anthropic::Models::BetaErrorResponse, Anthropic::Internal::AnyHash), type: Symbol)
+              .returns(T.attached_class)
+          end
+          def self.new(error:, type: :errored); end
+
+          sig { override.returns({error: Anthropic::Models::BetaErrorResponse, type: Symbol}) }
+          def to_hash; end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta/messages/beta_message_batch_expired_result.rbi

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Messages
+        class BetaMessageBatchExpiredResult < Anthropic::Internal::Type::BaseModel
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { params(type: Symbol).returns(T.attached_class) }
+          def self.new(type: :expired); end
+
+          sig { override.returns({type: Symbol}) }
+          def to_hash; end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta/messages/beta_message_batch_individual_response.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Messages
+        class BetaMessageBatchIndividualResponse < Anthropic::Internal::Type::BaseModel
+          # Developer-provided ID created for each request in a Message Batch. Useful for
+          # matching results to requests, as results may be given out of request order.
+          #
+          # Must be unique for each request within the Message Batch.
+          sig { returns(String) }
+          attr_accessor :custom_id
+
+          # Processing result for this request.
+          #
+          # Contains a Message output if processing was successful, an error response if
+          # processing failed, or the reason why processing was not attempted, such as
+          # cancellation or expiration.
+          sig do
+            returns(
+              T.any(
+                Anthropic::Models::Beta::Messages::BetaMessageBatchSucceededResult,
+                Anthropic::Models::Beta::Messages::BetaMessageBatchErroredResult,
+                Anthropic::Models::Beta::Messages::BetaMessageBatchCanceledResult,
+                Anthropic::Models::Beta::Messages::BetaMessageBatchExpiredResult
+              )
+            )
+          end
+          attr_accessor :result
+
+          # This is a single line in the response `.jsonl` file and does not represent the
+          # response as a whole.
+          sig do
+            params(
+              custom_id: String,
+              result: T.any(
+                Anthropic::Models::Beta::Messages::BetaMessageBatchSucceededResult,
+                Anthropic::Internal::AnyHash,
+                Anthropic::Models::Beta::Messages::BetaMessageBatchErroredResult,
+                Anthropic::Models::Beta::Messages::BetaMessageBatchCanceledResult,
+                Anthropic::Models::Beta::Messages::BetaMessageBatchExpiredResult
+              )
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(custom_id:, result:); end
+
+          sig do
+            override
+              .returns(
+                {
+                  custom_id: String,
+                  result: T.any(
+                    Anthropic::Models::Beta::Messages::BetaMessageBatchSucceededResult,
+                    Anthropic::Models::Beta::Messages::BetaMessageBatchErroredResult,
+                    Anthropic::Models::Beta::Messages::BetaMessageBatchCanceledResult,
+                    Anthropic::Models::Beta::Messages::BetaMessageBatchExpiredResult
+                  )
+                }
+              )
+          end
+          def to_hash; end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta/messages/beta_message_batch_request_counts.rbi

@@ -0,0 +1,63 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Messages
+        class BetaMessageBatchRequestCounts < Anthropic::Internal::Type::BaseModel
+          # Number of requests in the Message Batch that have been canceled.
+          #
+          # This is zero until processing of the entire Message Batch has ended.
+          sig { returns(Integer) }
+          attr_accessor :canceled
+
+          # Number of requests in the Message Batch that encountered an error.
+          #
+          # This is zero until processing of the entire Message Batch has ended.
+          sig { returns(Integer) }
+          attr_accessor :errored
+
+          # Number of requests in the Message Batch that have expired.
+          #
+          # This is zero until processing of the entire Message Batch has ended.
+          sig { returns(Integer) }
+          attr_accessor :expired
+
+          # Number of requests in the Message Batch that are processing.
+          sig { returns(Integer) }
+          attr_accessor :processing
+
+          # Number of requests in the Message Batch that have completed successfully.
+          #
+          # This is zero until processing of the entire Message Batch has ended.
+          sig { returns(Integer) }
+          attr_accessor :succeeded
+
+          sig do
+            params(
+              canceled: Integer,
+              errored: Integer,
+              expired: Integer,
+              processing: Integer,
+              succeeded: Integer
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(canceled:, errored:, expired:, processing:, succeeded:); end
+
+          sig do
+            override
+              .returns({
+                         canceled: Integer,
+                         errored: Integer,
+                         expired: Integer,
+                         processing: Integer,
+                         succeeded: Integer
+                       })
+          end
+          def to_hash; end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta/messages/beta_message_batch_result.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Messages
+        # Processing result for this request.
+        #
+        # Contains a Message output if processing was successful, an error response if
+        # processing failed, or the reason why processing was not attempted, such as
+        # cancellation or expiration.
+        module BetaMessageBatchResult
+          extend Anthropic::Internal::Type::Union
+
+          sig do
+            override
+              .returns(
+                [Anthropic::Models::Beta::Messages::BetaMessageBatchSucceededResult, Anthropic::Models::Beta::Messages::BetaMessageBatchErroredResult, Anthropic::Models::Beta::Messages::BetaMessageBatchCanceledResult, Anthropic::Models::Beta::Messages::BetaMessageBatchExpiredResult]
+              )
+          end
+          def self.variants; end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta/messages/beta_message_batch_succeeded_result.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      module Messages
+        class BetaMessageBatchSucceededResult < Anthropic::Internal::Type::BaseModel
+          sig { returns(Anthropic::Models::Beta::BetaMessage) }
+          attr_reader :message
+
+          sig { params(message: T.any(Anthropic::Models::Beta::BetaMessage, Anthropic::Internal::AnyHash)).void }
+          attr_writer :message
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(message: T.any(Anthropic::Models::Beta::BetaMessage, Anthropic::Internal::AnyHash), type: Symbol)
+              .returns(T.attached_class)
+          end
+          def self.new(message:, type: :succeeded); end
+
+          sig { override.returns({message: Anthropic::Models::Beta::BetaMessage, type: Symbol}) }
+          def to_hash; end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta/model_list_params.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      class ModelListParams < Anthropic::Internal::Type::BaseModel
+        extend Anthropic::Internal::Type::RequestParameters::Converter
+        include Anthropic::Internal::Type::RequestParameters
+
+        # ID of the object to use as a cursor for pagination. When provided, returns the
+        # page of results immediately after this object.
+        sig { returns(T.nilable(String)) }
+        attr_reader :after_id
+
+        sig { params(after_id: String).void }
+        attr_writer :after_id
+
+        # ID of the object to use as a cursor for pagination. When provided, returns the
+        # page of results immediately before this object.
+        sig { returns(T.nilable(String)) }
+        attr_reader :before_id
+
+        sig { params(before_id: String).void }
+        attr_writer :before_id
+
+        # Number of items to return per page.
+        #
+        # Defaults to `20`. Ranges from `1` to `1000`.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :limit
+
+        sig { params(limit: Integer).void }
+        attr_writer :limit
+
+        sig do
+          params(
+            after_id: String,
+            before_id: String,
+            limit: Integer,
+            request_options: T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(after_id: nil, before_id: nil, limit: nil, request_options: {}); end
+
+        sig do
+          override
+            .returns({
+                       after_id: String,
+                       before_id: String,
+                       limit: Integer,
+                       request_options: Anthropic::RequestOptions
+                     })
+        end
+        def to_hash; end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta/model_retrieve_params.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Beta
+      class ModelRetrieveParams < Anthropic::Internal::Type::BaseModel
+        extend Anthropic::Internal::Type::RequestParameters::Converter
+        include Anthropic::Internal::Type::RequestParameters
+
+        sig do
+          params(request_options: T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash))
+            .returns(T.attached_class)
+        end
+        def self.new(request_options: {}); end
+
+        sig { override.returns({request_options: Anthropic::RequestOptions}) }
+        def to_hash; end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta_api_error.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BetaAPIError < Anthropic::Internal::Type::BaseModel
+      sig { returns(String) }
+      attr_accessor :message
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig { params(message: String, type: Symbol).returns(T.attached_class) }
+      def self.new(message:, type: :api_error); end
+
+      sig { override.returns({message: String, type: Symbol}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta_authentication_error.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BetaAuthenticationError < Anthropic::Internal::Type::BaseModel
+      sig { returns(String) }
+      attr_accessor :message
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig { params(message: String, type: Symbol).returns(T.attached_class) }
+      def self.new(message:, type: :authentication_error); end
+
+      sig { override.returns({message: String, type: Symbol}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta_billing_error.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BetaBillingError < Anthropic::Internal::Type::BaseModel
+      sig { returns(String) }
+      attr_accessor :message
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig { params(message: String, type: Symbol).returns(T.attached_class) }
+      def self.new(message:, type: :billing_error); end
+
+      sig { override.returns({message: String, type: Symbol}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/beta_error.rbi

@@ -0,0 +1,17 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module BetaError
+      extend Anthropic::Internal::Type::Union
+
+      sig do
+        override
+          .returns(
+            [Anthropic::Models::BetaInvalidRequestError, Anthropic::Models::BetaAuthenticationError, Anthropic::Models::BetaBillingError, Anthropic::Models::BetaPermissionError, Anthropic::Models::BetaNotFoundError, Anthropic::Models::BetaRateLimitError, Anthropic::Models::BetaGatewayTimeoutError, Anthropic::Models::BetaAPIError, Anthropic::Models::BetaOverloadedError]
+          )
+      end
+      def self.variants; end
+    end
+  end
+end