anthropic 0.4.0 → 1.0.0

data/rbi/anthropic/models/messages/batch_delete_params.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Messages
+      class BatchDeleteParams < Anthropic::Internal::Type::BaseModel
+        extend Anthropic::Internal::Type::RequestParameters::Converter
+        include Anthropic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Messages::BatchDeleteParams,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig do
+          params(request_options: Anthropic::RequestOptions::OrHash).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/anthropic/models/messages/batch_list_params.rbi

@@ -0,0 +1,81 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Messages
+      class BatchListParams < Anthropic::Internal::Type::BaseModel
+        extend Anthropic::Internal::Type::RequestParameters::Converter
+        include Anthropic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Messages::BatchListParams,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # 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: Anthropic::RequestOptions::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # 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
+
+        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/anthropic/models/messages/batch_results_params.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Messages
+      class BatchResultsParams < Anthropic::Internal::Type::BaseModel
+        extend Anthropic::Internal::Type::RequestParameters::Converter
+        include Anthropic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Messages::BatchResultsParams,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig do
+          params(request_options: Anthropic::RequestOptions::OrHash).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/anthropic/models/messages/batch_retrieve_params.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Messages
+      class BatchRetrieveParams < Anthropic::Internal::Type::BaseModel
+        extend Anthropic::Internal::Type::RequestParameters::Converter
+        include Anthropic::Internal::Type::RequestParameters
+
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Messages::BatchRetrieveParams,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig do
+          params(request_options: Anthropic::RequestOptions::OrHash).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/anthropic/models/messages/deleted_message_batch.rbi

@@ -0,0 +1,42 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Messages
+      class DeletedMessageBatch < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Messages::DeletedMessageBatch,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # 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 of the Message Batch.
+          id:,
+          # Deleted object type.
+          #
+          # For Message Batches, this is always `"message_batch_deleted"`.
+          type: :message_batch_deleted
+        )
+        end
+
+        sig { override.returns({ id: String, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/messages/message_batch.rbi

@@ -0,0 +1,208 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    MessageBatch = Messages::MessageBatch
+
+    module Messages
+      class MessageBatch < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Messages::MessageBatch,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # 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 do
+          returns(
+            Anthropic::Messages::MessageBatch::ProcessingStatus::TaggedSymbol
+          )
+        end
+        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::Messages::MessageBatchRequestCounts) }
+        attr_reader :request_counts
+
+        sig do
+          params(
+            request_counts:
+              Anthropic::Messages::MessageBatchRequestCounts::OrHash
+          ).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::Messages::MessageBatch::ProcessingStatus::OrSymbol,
+            request_counts:
+              Anthropic::Messages::MessageBatchRequestCounts::OrHash,
+            results_url: T.nilable(String),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Unique object identifier.
+          #
+          # The format and length of IDs may change over time.
+          id:,
+          # RFC 3339 datetime string representing the time at which the Message Batch was
+          # archived and its results became unavailable.
+          archived_at:,
+          # RFC 3339 datetime string representing the time at which cancellation was
+          # initiated for the Message Batch. Specified only if cancellation was initiated.
+          cancel_initiated_at:,
+          # RFC 3339 datetime string representing the time at which the Message Batch was
+          # created.
+          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.
+          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.
+          expires_at:,
+          # Processing status of the Message Batch.
+          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.
+          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.
+          results_url:,
+          # Object type.
+          #
+          # For Message Batches, this is always `"message_batch"`.
+          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::Messages::MessageBatch::ProcessingStatus::TaggedSymbol,
+              request_counts: Anthropic::Messages::MessageBatchRequestCounts,
+              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 do
+              T.all(Symbol, Anthropic::Messages::MessageBatch::ProcessingStatus)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          IN_PROGRESS =
+            T.let(
+              :in_progress,
+              Anthropic::Messages::MessageBatch::ProcessingStatus::TaggedSymbol
+            )
+          CANCELING =
+            T.let(
+              :canceling,
+              Anthropic::Messages::MessageBatch::ProcessingStatus::TaggedSymbol
+            )
+          ENDED =
+            T.let(
+              :ended,
+              Anthropic::Messages::MessageBatch::ProcessingStatus::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Anthropic::Messages::MessageBatch::ProcessingStatus::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/messages/message_batch_canceled_result.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    MessageBatchCanceledResult = Messages::MessageBatchCanceledResult
+
+    module Messages
+      class MessageBatchCanceledResult < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Messages::MessageBatchCanceledResult,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        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

data/rbi/anthropic/models/messages/message_batch_errored_result.rbi

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

data/rbi/anthropic/models/messages/message_batch_expired_result.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    MessageBatchExpiredResult = Messages::MessageBatchExpiredResult
+
+    module Messages
+      class MessageBatchExpiredResult < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Messages::MessageBatchExpiredResult,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        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

data/rbi/anthropic/models/messages/message_batch_individual_response.rbi

@@ -0,0 +1,74 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    MessageBatchIndividualResponse = Messages::MessageBatchIndividualResponse
+
+    module Messages
+      class MessageBatchIndividualResponse < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Messages::MessageBatchIndividualResponse,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # 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 { returns(Anthropic::Messages::MessageBatchResult::Variants) }
+        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::Messages::MessageBatchSucceededResult::OrHash,
+                Anthropic::Messages::MessageBatchErroredResult::OrHash,
+                Anthropic::Messages::MessageBatchCanceledResult::OrHash,
+                Anthropic::Messages::MessageBatchExpiredResult::OrHash
+              )
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # 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.
+          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.
+          result:
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              custom_id: String,
+              result: Anthropic::Messages::MessageBatchResult::Variants
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/messages/message_batch_request_counts.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    MessageBatchRequestCounts = Messages::MessageBatchRequestCounts
+
+    module Messages
+      class MessageBatchRequestCounts < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Messages::MessageBatchRequestCounts,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # 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(
+          # Number of requests in the Message Batch that have been canceled.
+          #
+          # This is zero until processing of the entire Message Batch has ended.
+          canceled:,
+          # Number of requests in the Message Batch that encountered an error.
+          #
+          # This is zero until processing of the entire Message Batch has ended.
+          errored:,
+          # Number of requests in the Message Batch that have expired.
+          #
+          # This is zero until processing of the entire Message Batch has ended.
+          expired:,
+          # Number of requests in the Message Batch that are processing.
+          processing:,
+          # Number of requests in the Message Batch that have completed successfully.
+          #
+          # This is zero until processing of the entire Message Batch has ended.
+          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