anthropic 0.4.1 → 1.1.0

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

@@ -0,0 +1,36 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    MessageBatchResult = Messages::MessageBatchResult
+
+    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
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Anthropic::Messages::MessageBatchSucceededResult,
+              Anthropic::Messages::MessageBatchErroredResult,
+              Anthropic::Messages::MessageBatchCanceledResult,
+              Anthropic::Messages::MessageBatchExpiredResult
+            )
+          end
+
+        sig do
+          override.returns(
+            T::Array[Anthropic::Messages::MessageBatchResult::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

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

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

data/rbi/anthropic/models/metadata.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class Metadata < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::Metadata, Anthropic::Internal::AnyHash)
+        end
+
+      # 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(
+        # 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.
+        user_id: nil
+      )
+      end
+
+      sig { override.returns({ user_id: T.nilable(String) }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/model.rbi

@@ -0,0 +1,92 @@
+# 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
+
+      Variants = T.type_alias { T.any(Anthropic::Model::TaggedSymbol, String) }
+
+      sig { override.returns(T::Array[Anthropic::Model::Variants]) }
+      def self.variants
+      end
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Anthropic::Model) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      # High-performance model with early extended thinking
+      CLAUDE_3_7_SONNET_LATEST =
+        T.let(:"claude-3-7-sonnet-latest", Anthropic::Model::TaggedSymbol)
+
+      # High-performance model with early extended thinking
+      CLAUDE_3_7_SONNET_20250219 =
+        T.let(:"claude-3-7-sonnet-20250219", Anthropic::Model::TaggedSymbol)
+
+      # Fastest and most compact model for near-instant responsiveness
+      CLAUDE_3_5_HAIKU_LATEST =
+        T.let(:"claude-3-5-haiku-latest", Anthropic::Model::TaggedSymbol)
+
+      # Our fastest model
+      CLAUDE_3_5_HAIKU_20241022 =
+        T.let(:"claude-3-5-haiku-20241022", Anthropic::Model::TaggedSymbol)
+
+      # High-performance model with extended thinking
+      CLAUDE_SONNET_4_20250514 =
+        T.let(:"claude-sonnet-4-20250514", Anthropic::Model::TaggedSymbol)
+
+      # High-performance model with extended thinking
+      CLAUDE_SONNET_4_0 =
+        T.let(:"claude-sonnet-4-0", Anthropic::Model::TaggedSymbol)
+
+      # High-performance model with extended thinking
+      CLAUDE_4_SONNET_20250514 =
+        T.let(:"claude-4-sonnet-20250514", Anthropic::Model::TaggedSymbol)
+
+      # Our previous most intelligent model
+      CLAUDE_3_5_SONNET_LATEST =
+        T.let(:"claude-3-5-sonnet-latest", Anthropic::Model::TaggedSymbol)
+
+      # Our previous most intelligent model
+      CLAUDE_3_5_SONNET_20241022 =
+        T.let(:"claude-3-5-sonnet-20241022", Anthropic::Model::TaggedSymbol)
+
+      CLAUDE_3_5_SONNET_20240620 =
+        T.let(:"claude-3-5-sonnet-20240620", Anthropic::Model::TaggedSymbol)
+
+      # Our most capable model
+      CLAUDE_OPUS_4_0 =
+        T.let(:"claude-opus-4-0", Anthropic::Model::TaggedSymbol)
+
+      # Our most capable model
+      CLAUDE_OPUS_4_20250514 =
+        T.let(:"claude-opus-4-20250514", Anthropic::Model::TaggedSymbol)
+
+      # Our most capable model
+      CLAUDE_4_OPUS_20250514 =
+        T.let(:"claude-4-opus-20250514", Anthropic::Model::TaggedSymbol)
+
+      # Excels at writing and complex tasks
+      CLAUDE_3_OPUS_LATEST =
+        T.let(:"claude-3-opus-latest", Anthropic::Model::TaggedSymbol)
+
+      # Excels at writing and complex tasks
+      CLAUDE_3_OPUS_20240229 =
+        T.let(:"claude-3-opus-20240229", Anthropic::Model::TaggedSymbol)
+
+      # Balance of speed and intelligence
+      CLAUDE_3_SONNET_20240229 =
+        T.let(:"claude-3-sonnet-20240229", Anthropic::Model::TaggedSymbol)
+
+      # Our previous most fast and cost-effective
+      CLAUDE_3_HAIKU_20240307 =
+        T.let(:"claude-3-haiku-20240307", Anthropic::Model::TaggedSymbol)
+
+      CLAUDE_2_1 = T.let(:"claude-2.1", Anthropic::Model::TaggedSymbol)
+
+      CLAUDE_2_0 = T.let(:"claude-2.0", Anthropic::Model::TaggedSymbol)
+    end
+  end
+end

data/rbi/anthropic/models/model_info.rbi

@@ -0,0 +1,62 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ModelInfo < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::ModelInfo, Anthropic::Internal::AnyHash)
+        end
+
+      # 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(
+        # Unique model identifier.
+        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.
+        created_at:,
+        # A human-readable name for the model.
+        display_name:,
+        # Object type.
+        #
+        # For Models, this is always `"model"`.
+        type: :model
+      )
+      end
+
+      sig do
+        override.returns(
+          { id: String, created_at: Time, display_name: String, type: Symbol }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/model_list_params.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ModelListParams < Anthropic::Internal::Type::BaseModel
+      extend Anthropic::Internal::Type::RequestParameters::Converter
+      include Anthropic::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::ModelListParams, 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
+
+      # Optional header to specify the beta version(s) you want to use.
+      sig do
+        returns(
+          T.nilable(T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)])
+        )
+      end
+      attr_reader :betas
+
+      sig do
+        params(
+          betas: T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)]
+        ).void
+      end
+      attr_writer :betas
+
+      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(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,
+        # Optional header to specify the beta version(s) you want to use.
+        betas: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            after_id: String,
+            before_id: String,
+            limit: Integer,
+            betas: T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)],
+            request_options: Anthropic::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/model_retrieve_params.rbi

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

data/rbi/anthropic/models/not_found_error.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class NotFoundError < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::NotFoundError, Anthropic::Internal::AnyHash)
+        end
+
+      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/anthropic/models/overloaded_error.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class OverloadedError < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::OverloadedError, Anthropic::Internal::AnyHash)
+        end
+
+      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/anthropic/models/permission_error.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class PermissionError < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::PermissionError, Anthropic::Internal::AnyHash)
+        end
+
+      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/anthropic/models/plain_text_source.rbi

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

data/rbi/anthropic/models/rate_limit_error.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class RateLimitError < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::RateLimitError, Anthropic::Internal::AnyHash)
+        end
+
+      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: :rate_limit_error)
+      end
+
+      sig { override.returns({ message: String, type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/raw_content_block_delta.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module RawContentBlockDelta
+      extend Anthropic::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Anthropic::TextDelta,
+            Anthropic::InputJSONDelta,
+            Anthropic::CitationsDelta,
+            Anthropic::ThinkingDelta,
+            Anthropic::SignatureDelta
+          )
+        end
+
+      sig do
+        override.returns(T::Array[Anthropic::RawContentBlockDelta::Variants])
+      end
+      def self.variants
+      end
+    end
+  end
+end

data/rbi/anthropic/models/raw_content_block_delta_event.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class RawContentBlockDeltaEvent < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::RawContentBlockDeltaEvent,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Anthropic::RawContentBlockDelta::Variants) }
+      attr_accessor :delta
+
+      sig { returns(Integer) }
+      attr_accessor :index
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+          delta:
+            T.any(
+              Anthropic::TextDelta::OrHash,
+              Anthropic::InputJSONDelta::OrHash,
+              Anthropic::CitationsDelta::OrHash,
+              Anthropic::ThinkingDelta::OrHash,
+              Anthropic::SignatureDelta::OrHash
+            ),
+          index: Integer,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(delta:, index:, type: :content_block_delta)
+      end
+
+      sig do
+        override.returns(
+          {
+            delta: Anthropic::RawContentBlockDelta::Variants,
+            index: Integer,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end