anthropic 0.4.0 → 1.0.0

data/rbi/anthropic/models/beta/beta_raw_content_block_start_event.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaRawContentBlockStartEvent = Beta::BetaRawContentBlockStartEvent
+
+    module Beta
+      class BetaRawContentBlockStartEvent < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaRawContentBlockStartEvent,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            Anthropic::Beta::BetaRawContentBlockStartEvent::ContentBlock::Variants
+          )
+        end
+        attr_accessor :content_block
+
+        sig { returns(Integer) }
+        attr_accessor :index
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            content_block:
+              T.any(
+                Anthropic::Beta::BetaTextBlock::OrHash,
+                Anthropic::Beta::BetaToolUseBlock::OrHash,
+                Anthropic::Beta::BetaServerToolUseBlock::OrHash,
+                Anthropic::Beta::BetaWebSearchToolResultBlock::OrHash,
+                Anthropic::Beta::BetaThinkingBlock::OrHash,
+                Anthropic::Beta::BetaRedactedThinkingBlock::OrHash
+              ),
+            index: Integer,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(content_block:, index:, type: :content_block_start)
+        end
+
+        sig do
+          override.returns(
+            {
+              content_block:
+                Anthropic::Beta::BetaRawContentBlockStartEvent::ContentBlock::Variants,
+              index: Integer,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module ContentBlock
+          extend Anthropic::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                Anthropic::Beta::BetaTextBlock,
+                Anthropic::Beta::BetaToolUseBlock,
+                Anthropic::Beta::BetaServerToolUseBlock,
+                Anthropic::Beta::BetaWebSearchToolResultBlock,
+                Anthropic::Beta::BetaThinkingBlock,
+                Anthropic::Beta::BetaRedactedThinkingBlock
+              )
+            end
+
+          sig do
+            override.returns(
+              T::Array[
+                Anthropic::Beta::BetaRawContentBlockStartEvent::ContentBlock::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_raw_content_block_stop_event.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaRawContentBlockStopEvent = Beta::BetaRawContentBlockStopEvent
+
+    module Beta
+      class BetaRawContentBlockStopEvent < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaRawContentBlockStopEvent,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Integer) }
+        attr_accessor :index
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig { params(index: Integer, type: Symbol).returns(T.attached_class) }
+        def self.new(index:, type: :content_block_stop)
+        end
+
+        sig { override.returns({ index: Integer, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_raw_message_delta_event.rbi

@@ -0,0 +1,135 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaRawMessageDeltaEvent = Beta::BetaRawMessageDeltaEvent
+
+    module Beta
+      class BetaRawMessageDeltaEvent < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaRawMessageDeltaEvent,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Anthropic::Beta::BetaRawMessageDeltaEvent::Delta) }
+        attr_reader :delta
+
+        sig do
+          params(
+            delta: Anthropic::Beta::BetaRawMessageDeltaEvent::Delta::OrHash
+          ).void
+        end
+        attr_writer :delta
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Billing and rate-limit usage.
+        #
+        # Anthropic's API bills and rate-limits by token counts, as tokens represent the
+        # underlying cost to our systems.
+        #
+        # Under the hood, the API transforms requests into a format suitable for the
+        # model. The model's output then goes through a parsing stage before becoming an
+        # API response. As a result, the token counts in `usage` will not match one-to-one
+        # with the exact visible content of an API request or response.
+        #
+        # For example, `output_tokens` will be non-zero, even for an empty string response
+        # from Claude.
+        #
+        # Total input tokens in a request is the summation of `input_tokens`,
+        # `cache_creation_input_tokens`, and `cache_read_input_tokens`.
+        sig { returns(Anthropic::Beta::BetaMessageDeltaUsage) }
+        attr_reader :usage
+
+        sig do
+          params(usage: Anthropic::Beta::BetaMessageDeltaUsage::OrHash).void
+        end
+        attr_writer :usage
+
+        sig do
+          params(
+            delta: Anthropic::Beta::BetaRawMessageDeltaEvent::Delta::OrHash,
+            usage: Anthropic::Beta::BetaMessageDeltaUsage::OrHash,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          delta:,
+          # Billing and rate-limit usage.
+          #
+          # Anthropic's API bills and rate-limits by token counts, as tokens represent the
+          # underlying cost to our systems.
+          #
+          # Under the hood, the API transforms requests into a format suitable for the
+          # model. The model's output then goes through a parsing stage before becoming an
+          # API response. As a result, the token counts in `usage` will not match one-to-one
+          # with the exact visible content of an API request or response.
+          #
+          # For example, `output_tokens` will be non-zero, even for an empty string response
+          # from Claude.
+          #
+          # Total input tokens in a request is the summation of `input_tokens`,
+          # `cache_creation_input_tokens`, and `cache_read_input_tokens`.
+          usage:,
+          type: :message_delta
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              delta: Anthropic::Beta::BetaRawMessageDeltaEvent::Delta,
+              type: Symbol,
+              usage: Anthropic::Beta::BetaMessageDeltaUsage
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Delta < Anthropic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Anthropic::Beta::BetaRawMessageDeltaEvent::Delta,
+                Anthropic::Internal::AnyHash
+              )
+            end
+
+          sig do
+            returns(T.nilable(Anthropic::Beta::BetaStopReason::TaggedSymbol))
+          end
+          attr_accessor :stop_reason
+
+          sig { returns(T.nilable(String)) }
+          attr_accessor :stop_sequence
+
+          sig do
+            params(
+              stop_reason: T.nilable(Anthropic::Beta::BetaStopReason::OrSymbol),
+              stop_sequence: T.nilable(String)
+            ).returns(T.attached_class)
+          end
+          def self.new(stop_reason:, stop_sequence:)
+          end
+
+          sig do
+            override.returns(
+              {
+                stop_reason:
+                  T.nilable(Anthropic::Beta::BetaStopReason::TaggedSymbol),
+                stop_sequence: T.nilable(String)
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_raw_message_start_event.rbi

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

data/rbi/anthropic/models/beta/beta_raw_message_stop_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaRawMessageStopEvent = Beta::BetaRawMessageStopEvent
+
+    module Beta
+      class BetaRawMessageStopEvent < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaRawMessageStopEvent,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig { params(type: Symbol).returns(T.attached_class) }
+        def self.new(type: :message_stop)
+        end
+
+        sig { override.returns({ type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_raw_message_stream_event.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaRawMessageStreamEvent = Beta::BetaRawMessageStreamEvent
+
+    module Beta
+      module BetaRawMessageStreamEvent
+        extend Anthropic::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaRawMessageStartEvent,
+              Anthropic::Beta::BetaRawMessageDeltaEvent,
+              Anthropic::Beta::BetaRawMessageStopEvent,
+              Anthropic::Beta::BetaRawContentBlockStartEvent,
+              Anthropic::Beta::BetaRawContentBlockDeltaEvent,
+              Anthropic::Beta::BetaRawContentBlockStopEvent
+            )
+          end
+
+        sig do
+          override.returns(
+            T::Array[Anthropic::Beta::BetaRawMessageStreamEvent::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_redacted_thinking_block.rbi

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

data/rbi/anthropic/models/beta/beta_redacted_thinking_block_param.rbi

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

data/rbi/anthropic/models/beta/beta_server_tool_usage.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaServerToolUsage = Beta::BetaServerToolUsage
+
+    module Beta
+      class BetaServerToolUsage < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaServerToolUsage,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # The number of web search tool requests.
+        sig { returns(Integer) }
+        attr_accessor :web_search_requests
+
+        sig { params(web_search_requests: Integer).returns(T.attached_class) }
+        def self.new(
+          # The number of web search tool requests.
+          web_search_requests:
+        )
+        end
+
+        sig { override.returns({ web_search_requests: Integer }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_server_tool_use_block.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaServerToolUseBlock = Beta::BetaServerToolUseBlock
+
+    module Beta
+      class BetaServerToolUseBlock < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaServerToolUseBlock,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T.anything) }
+        attr_accessor :input
+
+        sig { returns(Symbol) }
+        attr_accessor :name
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            id: String,
+            input: T.anything,
+            name: Symbol,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(id:, input:, name: :web_search, type: :server_tool_use)
+        end
+
+        sig do
+          override.returns(
+            { id: String, input: T.anything, name: Symbol, type: Symbol }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_server_tool_use_block_param.rbi

@@ -0,0 +1,78 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaServerToolUseBlockParam = Beta::BetaServerToolUseBlockParam
+
+    module Beta
+      class BetaServerToolUseBlockParam < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaServerToolUseBlockParam,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig { returns(T.anything) }
+        attr_accessor :input
+
+        sig { returns(Symbol) }
+        attr_accessor :name
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Create a cache control breakpoint at this content block.
+        sig { returns(T.nilable(Anthropic::Beta::BetaCacheControlEphemeral)) }
+        attr_reader :cache_control
+
+        sig do
+          params(
+            cache_control:
+              T.nilable(Anthropic::Beta::BetaCacheControlEphemeral::OrHash)
+          ).void
+        end
+        attr_writer :cache_control
+
+        sig do
+          params(
+            id: String,
+            input: T.anything,
+            cache_control:
+              T.nilable(Anthropic::Beta::BetaCacheControlEphemeral::OrHash),
+            name: Symbol,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          id:,
+          input:,
+          # Create a cache control breakpoint at this content block.
+          cache_control: nil,
+          name: :web_search,
+          type: :server_tool_use
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              input: T.anything,
+              name: Symbol,
+              type: Symbol,
+              cache_control:
+                T.nilable(Anthropic::Beta::BetaCacheControlEphemeral)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_signature_delta.rbi

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

data/rbi/anthropic/models/beta/beta_stop_reason.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaStopReason = Beta::BetaStopReason
+
+    module Beta
+      module BetaStopReason
+        extend Anthropic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Anthropic::Beta::BetaStopReason) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        END_TURN =
+          T.let(:end_turn, Anthropic::Beta::BetaStopReason::TaggedSymbol)
+        MAX_TOKENS =
+          T.let(:max_tokens, Anthropic::Beta::BetaStopReason::TaggedSymbol)
+        STOP_SEQUENCE =
+          T.let(:stop_sequence, Anthropic::Beta::BetaStopReason::TaggedSymbol)
+        TOOL_USE =
+          T.let(:tool_use, Anthropic::Beta::BetaStopReason::TaggedSymbol)
+        PAUSE_TURN =
+          T.let(:pause_turn, Anthropic::Beta::BetaStopReason::TaggedSymbol)
+        REFUSAL = T.let(:refusal, Anthropic::Beta::BetaStopReason::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Anthropic::Beta::BetaStopReason::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end