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

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

@@ -0,0 +1,143 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Messages
+      class MessageBatch < 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::Messages::MessageBatch::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::Messages::MessageBatchRequestCounts) }
+        attr_reader :request_counts
+
+        sig do
+          params(
+            request_counts: T.any(Anthropic::Models::Messages::MessageBatchRequestCounts, 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::Messages::MessageBatch::ProcessingStatus::OrSymbol,
+            request_counts: T.any(Anthropic::Models::Messages::MessageBatchRequestCounts, 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::Messages::MessageBatch::ProcessingStatus::TaggedSymbol,
+                request_counts: Anthropic::Models::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 { T.all(Symbol, Anthropic::Models::Messages::MessageBatch::ProcessingStatus) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, String, Anthropic::Models::Messages::MessageBatch::ProcessingStatus::TaggedSymbol) }
+
+          IN_PROGRESS =
+            T.let(:in_progress, Anthropic::Models::Messages::MessageBatch::ProcessingStatus::TaggedSymbol)
+          CANCELING = T.let(:canceling, Anthropic::Models::Messages::MessageBatch::ProcessingStatus::TaggedSymbol)
+          ENDED = T.let(:ended, Anthropic::Models::Messages::MessageBatch::ProcessingStatus::TaggedSymbol)
+
+          sig { override.returns(T::Array[Anthropic::Models::Messages::MessageBatch::ProcessingStatus::TaggedSymbol]) }
+          def self.values; end
+        end
+      end
+    end
+
+    MessageBatch = Messages::MessageBatch
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Messages
+      class MessageBatchCanceledResult < 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
+
+    MessageBatchCanceledResult = Messages::MessageBatchCanceledResult
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Messages
+      class MessageBatchExpiredResult < 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
+
+    MessageBatchExpiredResult = Messages::MessageBatchExpiredResult
+  end
+end

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

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

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

@@ -0,0 +1,63 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module Messages
+      class MessageBatchRequestCounts < 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
+
+    MessageBatchRequestCounts = Messages::MessageBatchRequestCounts
+  end
+end

data/rbi/lib/anthropic/models/messages/message_batch_result.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    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 MessageBatchResult
+        extend Anthropic::Internal::Type::Union
+
+        sig do
+          override
+            .returns(
+              [Anthropic::Models::Messages::MessageBatchSucceededResult, Anthropic::Models::Messages::MessageBatchErroredResult, Anthropic::Models::Messages::MessageBatchCanceledResult, Anthropic::Models::Messages::MessageBatchExpiredResult]
+            )
+        end
+        def self.variants; end
+      end
+    end
+
+    MessageBatchResult = Messages::MessageBatchResult
+  end
+end

data/rbi/lib/anthropic/models/messages/message_batch_succeeded_result.rbi

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

data/rbi/lib/anthropic/models/metadata.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class Metadata < Anthropic::Internal::Type::BaseModel
+      # An external identifier for the user who is associated with the request.
+      #
+      # This should be a uuid, hash value, or other opaque identifier. Anthropic may use
+      # this id to help detect abuse. Do not include any identifying information such as
+      # name, email address, or phone number.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :user_id
+
+      sig { params(user_id: T.nilable(String)).returns(T.attached_class) }
+      def self.new(user_id: nil); end
+
+      sig { override.returns({user_id: T.nilable(String)}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/model.rbi

@@ -0,0 +1,54 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    # The model that will complete your prompt.\n\nSee
+    # [models](https://docs.anthropic.com/en/docs/models-overview) for additional
+    # details and options.
+    module Model
+      extend Anthropic::Internal::Type::Union
+
+      sig { override.returns([Anthropic::Models::Model::OrSymbol, String]) }
+      def self.variants; end
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Anthropic::Models::Model) }
+      OrSymbol = T.type_alias { T.any(Symbol, String, Anthropic::Models::Model::TaggedSymbol) }
+
+      # Our most intelligent model
+      CLAUDE_3_7_SONNET_LATEST = T.let(:"claude-3-7-sonnet-latest", Anthropic::Models::Model::TaggedSymbol)
+
+      # Our most intelligent model
+      CLAUDE_3_7_SONNET_20250219 = T.let(:"claude-3-7-sonnet-20250219", Anthropic::Models::Model::TaggedSymbol)
+
+      # Fastest and most compact model for near-instant responsiveness
+      CLAUDE_3_5_HAIKU_LATEST = T.let(:"claude-3-5-haiku-latest", Anthropic::Models::Model::TaggedSymbol)
+
+      # Our fastest model
+      CLAUDE_3_5_HAIKU_20241022 = T.let(:"claude-3-5-haiku-20241022", Anthropic::Models::Model::TaggedSymbol)
+
+      # Our previous most intelligent model
+      CLAUDE_3_5_SONNET_LATEST = T.let(:"claude-3-5-sonnet-latest", Anthropic::Models::Model::TaggedSymbol)
+
+      # Our previous most intelligent model
+      CLAUDE_3_5_SONNET_20241022 = T.let(:"claude-3-5-sonnet-20241022", Anthropic::Models::Model::TaggedSymbol)
+
+      CLAUDE_3_5_SONNET_20240620 = T.let(:"claude-3-5-sonnet-20240620", Anthropic::Models::Model::TaggedSymbol)
+
+      # Excels at writing and complex tasks
+      CLAUDE_3_OPUS_LATEST = T.let(:"claude-3-opus-latest", Anthropic::Models::Model::TaggedSymbol)
+
+      # Excels at writing and complex tasks
+      CLAUDE_3_OPUS_20240229 = T.let(:"claude-3-opus-20240229", Anthropic::Models::Model::TaggedSymbol)
+
+      # Balance of speed and intelligence
+      CLAUDE_3_SONNET_20240229 = T.let(:"claude-3-sonnet-20240229", Anthropic::Models::Model::TaggedSymbol)
+
+      # Our previous most fast and cost-effective
+      CLAUDE_3_HAIKU_20240307 = T.let(:"claude-3-haiku-20240307", Anthropic::Models::Model::TaggedSymbol)
+
+      CLAUDE_2_1 = T.let(:"claude-2.1", Anthropic::Models::Model::TaggedSymbol)
+
+      CLAUDE_2_0 = T.let(:"claude-2.0", Anthropic::Models::Model::TaggedSymbol)
+    end
+  end
+end

data/rbi/lib/anthropic/models/model_info.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ModelInfo < Anthropic::Internal::Type::BaseModel
+      # Unique model identifier.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # RFC 3339 datetime string representing the time at which the model was released.
+      # May be set to an epoch value if the release date is unknown.
+      sig { returns(Time) }
+      attr_accessor :created_at
+
+      # A human-readable name for the model.
+      sig { returns(String) }
+      attr_accessor :display_name
+
+      # Object type.
+      #
+      # For Models, this is always `"model"`.
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig do
+        params(id: String, created_at: Time, display_name: String, type: Symbol).returns(T.attached_class)
+      end
+      def self.new(id:, created_at:, display_name:, type: :model); end
+
+      sig { override.returns({id: String, created_at: Time, display_name: String, type: Symbol}) }
+      def to_hash; end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    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

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

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    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

data/rbi/lib/anthropic/models/not_found_error.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class NotFoundError < 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: :not_found_error); end
+
+      sig { override.returns({message: String, type: Symbol}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/overloaded_error.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class OverloadedError < 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: :overloaded_error); end
+
+      sig { override.returns({message: String, type: Symbol}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/permission_error.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class PermissionError < 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: :permission_error); end
+
+      sig { override.returns({message: String, type: Symbol}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/plain_text_source.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class PlainTextSource < Anthropic::Internal::Type::BaseModel
+      sig { returns(String) }
+      attr_accessor :data
+
+      sig { returns(Symbol) }
+      attr_accessor :media_type
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig { params(data: String, media_type: Symbol, type: Symbol).returns(T.attached_class) }
+      def self.new(data:, media_type: :"text/plain", type: :text); end
+
+      sig { override.returns({data: String, media_type: Symbol, type: Symbol}) }
+      def to_hash; end
+    end
+  end
+end