anthropic 0.4.1 → 1.1.0

data/rbi/anthropic/models/beta/beta_raw_content_block_delta_event.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaRawContentBlockDeltaEvent = Beta::BetaRawContentBlockDeltaEvent
+
+    module Beta
+      class BetaRawContentBlockDeltaEvent < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaRawContentBlockDeltaEvent,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Anthropic::Beta::BetaRawContentBlockDelta::Variants) }
+        attr_accessor :delta
+
+        sig { returns(Integer) }
+        attr_accessor :index
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            delta:
+              T.any(
+                Anthropic::Beta::BetaTextDelta::OrHash,
+                Anthropic::Beta::BetaInputJSONDelta::OrHash,
+                Anthropic::Beta::BetaCitationsDelta::OrHash,
+                Anthropic::Beta::BetaThinkingDelta::OrHash,
+                Anthropic::Beta::BetaSignatureDelta::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::Beta::BetaRawContentBlockDelta::Variants,
+              index: Integer,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+# 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
+
+        # Response model for a file uploaded to the container.
+        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::BetaCodeExecutionToolResultBlock::OrHash,
+                Anthropic::Beta::BetaMCPToolUseBlock::OrHash,
+                Anthropic::Beta::BetaMCPToolResultBlock::OrHash,
+                Anthropic::Beta::BetaContainerUploadBlock::OrHash,
+                Anthropic::Beta::BetaThinkingBlock::OrHash,
+                Anthropic::Beta::BetaRedactedThinkingBlock::OrHash
+              ),
+            index: Integer,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Response model for a file uploaded to the container.
+          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
+
+        # Response model for a file uploaded to the container.
+        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::BetaCodeExecutionToolResultBlock,
+                Anthropic::Beta::BetaMCPToolUseBlock,
+                Anthropic::Beta::BetaMCPToolResultBlock,
+                Anthropic::Beta::BetaContainerUploadBlock,
+                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,155 @@
+# 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
+
+          # Information about the container used in the request (for the code execution
+          # tool)
+          sig { returns(T.nilable(Anthropic::Beta::BetaContainer)) }
+          attr_reader :container
+
+          sig do
+            params(
+              container: T.nilable(Anthropic::Beta::BetaContainer::OrHash)
+            ).void
+          end
+          attr_writer :container
+
+          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(
+              container: T.nilable(Anthropic::Beta::BetaContainer::OrHash),
+              stop_reason: T.nilable(Anthropic::Beta::BetaStopReason::OrSymbol),
+              stop_sequence: T.nilable(String)
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Information about the container used in the request (for the code execution
+            # tool)
+            container:,
+            stop_reason:,
+            stop_sequence:
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                container: T.nilable(Anthropic::Beta::BetaContainer),
+                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_request_mcp_server_tool_configuration.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaRequestMCPServerToolConfiguration =
+      Beta::BetaRequestMCPServerToolConfiguration
+
+    module Beta
+      class BetaRequestMCPServerToolConfiguration < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaRequestMCPServerToolConfiguration,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :allowed_tools
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_accessor :enabled
+
+        sig do
+          params(
+            allowed_tools: T.nilable(T::Array[String]),
+            enabled: T.nilable(T::Boolean)
+          ).returns(T.attached_class)
+        end
+        def self.new(allowed_tools: nil, enabled: nil)
+        end
+
+        sig do
+          override.returns(
+            {
+              allowed_tools: T.nilable(T::Array[String]),
+              enabled: T.nilable(T::Boolean)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_request_mcp_server_url_definition.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaRequestMCPServerURLDefinition = Beta::BetaRequestMCPServerURLDefinition
+
+    module Beta
+      class BetaRequestMCPServerURLDefinition < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaRequestMCPServerURLDefinition,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :name
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig { returns(String) }
+        attr_accessor :url
+
+        sig { returns(T.nilable(String)) }
+        attr_accessor :authorization_token
+
+        sig do
+          returns(
+            T.nilable(Anthropic::Beta::BetaRequestMCPServerToolConfiguration)
+          )
+        end
+        attr_reader :tool_configuration
+
+        sig do
+          params(
+            tool_configuration:
+              T.nilable(
+                Anthropic::Beta::BetaRequestMCPServerToolConfiguration::OrHash
+              )
+          ).void
+        end
+        attr_writer :tool_configuration
+
+        sig do
+          params(
+            name: String,
+            url: String,
+            authorization_token: T.nilable(String),
+            tool_configuration:
+              T.nilable(
+                Anthropic::Beta::BetaRequestMCPServerToolConfiguration::OrHash
+              ),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          name:,
+          url:,
+          authorization_token: nil,
+          tool_configuration: nil,
+          type: :url
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              name: String,
+              type: Symbol,
+              url: String,
+              authorization_token: T.nilable(String),
+              tool_configuration:
+                T.nilable(
+                  Anthropic::Beta::BetaRequestMCPServerToolConfiguration
+                )
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end