anthropic 0.4.1 → 1.1.0

data/rbi/anthropic/models/beta/beta_text_delta.rbi

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

data/rbi/anthropic/models/beta/beta_thinking_block.rbi

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

data/rbi/anthropic/models/beta/beta_thinking_block_param.rbi

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

data/rbi/anthropic/models/beta/beta_thinking_config_disabled.rbi

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

data/rbi/anthropic/models/beta/beta_thinking_config_enabled.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaThinkingConfigEnabled = Beta::BetaThinkingConfigEnabled
+
+    module Beta
+      class BetaThinkingConfigEnabled < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaThinkingConfigEnabled,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # Determines how many tokens Claude can use for its internal reasoning process.
+        # Larger budgets can enable more thorough analysis for complex problems, improving
+        # response quality.
+        #
+        # Must be ≥1024 and less than `max_tokens`.
+        #
+        # See
+        # [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking)
+        # for details.
+        sig { returns(Integer) }
+        attr_accessor :budget_tokens
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(budget_tokens: Integer, type: Symbol).returns(T.attached_class)
+        end
+        def self.new(
+          # Determines how many tokens Claude can use for its internal reasoning process.
+          # Larger budgets can enable more thorough analysis for complex problems, improving
+          # response quality.
+          #
+          # Must be ≥1024 and less than `max_tokens`.
+          #
+          # See
+          # [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking)
+          # for details.
+          budget_tokens:,
+          type: :enabled
+        )
+        end
+
+        sig { override.returns({ budget_tokens: Integer, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_thinking_config_param.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaThinkingConfigParam = Beta::BetaThinkingConfigParam
+
+    module Beta
+      # Configuration for enabling Claude's extended thinking.
+      #
+      # When enabled, responses include `thinking` content blocks showing Claude's
+      # thinking process before the final answer. Requires a minimum budget of 1,024
+      # tokens and counts towards your `max_tokens` limit.
+      #
+      # See
+      # [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking)
+      # for details.
+      module BetaThinkingConfigParam
+        extend Anthropic::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaThinkingConfigEnabled,
+              Anthropic::Beta::BetaThinkingConfigDisabled
+            )
+          end
+
+        sig do
+          override.returns(
+            T::Array[Anthropic::Beta::BetaThinkingConfigParam::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_thinking_delta.rbi

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

data/rbi/anthropic/models/beta/beta_tool.rbi

@@ -0,0 +1,165 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaTool = Beta::BetaTool
+
+    module Beta
+      class BetaTool < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Anthropic::Beta::BetaTool, Anthropic::Internal::AnyHash)
+          end
+
+        # [JSON schema](https://json-schema.org/draft/2020-12) for this tool's input.
+        #
+        # This defines the shape of the `input` that your tool accepts and that the model
+        # will produce.
+        sig { returns(Anthropic::Beta::BetaTool::InputSchema) }
+        attr_reader :input_schema
+
+        sig do
+          params(
+            input_schema: Anthropic::Beta::BetaTool::InputSchema::OrHash
+          ).void
+        end
+        attr_writer :input_schema
+
+        # Name of the tool.
+        #
+        # This is how the tool will be called by the model and in `tool_use` blocks.
+        sig { returns(String) }
+        attr_accessor :name
+
+        # 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
+
+        # Description of what this tool does.
+        #
+        # Tool descriptions should be as detailed as possible. The more information that
+        # the model has about what the tool is and how to use it, the better it will
+        # perform. You can use natural language descriptions to reinforce important
+        # aspects of the tool input JSON schema.
+        sig { returns(T.nilable(String)) }
+        attr_reader :description
+
+        sig { params(description: String).void }
+        attr_writer :description
+
+        sig { returns(T.nilable(Anthropic::Beta::BetaTool::Type::OrSymbol)) }
+        attr_accessor :type
+
+        sig do
+          params(
+            input_schema: Anthropic::Beta::BetaTool::InputSchema::OrHash,
+            name: String,
+            cache_control:
+              T.nilable(Anthropic::Beta::BetaCacheControlEphemeral::OrHash),
+            description: String,
+            type: T.nilable(Anthropic::Beta::BetaTool::Type::OrSymbol)
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # [JSON schema](https://json-schema.org/draft/2020-12) for this tool's input.
+          #
+          # This defines the shape of the `input` that your tool accepts and that the model
+          # will produce.
+          input_schema:,
+          # Name of the tool.
+          #
+          # This is how the tool will be called by the model and in `tool_use` blocks.
+          name:,
+          # Create a cache control breakpoint at this content block.
+          cache_control: nil,
+          # Description of what this tool does.
+          #
+          # Tool descriptions should be as detailed as possible. The more information that
+          # the model has about what the tool is and how to use it, the better it will
+          # perform. You can use natural language descriptions to reinforce important
+          # aspects of the tool input JSON schema.
+          description: nil,
+          type: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              input_schema: Anthropic::Beta::BetaTool::InputSchema,
+              name: String,
+              cache_control:
+                T.nilable(Anthropic::Beta::BetaCacheControlEphemeral),
+              description: String,
+              type: T.nilable(Anthropic::Beta::BetaTool::Type::OrSymbol)
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class InputSchema < Anthropic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Anthropic::Beta::BetaTool::InputSchema,
+                Anthropic::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { returns(T.nilable(T.anything)) }
+          attr_accessor :properties
+
+          # [JSON schema](https://json-schema.org/draft/2020-12) for this tool's input.
+          #
+          # This defines the shape of the `input` that your tool accepts and that the model
+          # will produce.
+          sig do
+            params(properties: T.nilable(T.anything), type: Symbol).returns(
+              T.attached_class
+            )
+          end
+          def self.new(properties: nil, type: :object)
+          end
+
+          sig do
+            override.returns(
+              { type: Symbol, properties: T.nilable(T.anything) }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        module Type
+          extend Anthropic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias { T.all(Symbol, Anthropic::Beta::BetaTool::Type) }
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          CUSTOM = T.let(:custom, Anthropic::Beta::BetaTool::Type::TaggedSymbol)
+
+          sig do
+            override.returns(
+              T::Array[Anthropic::Beta::BetaTool::Type::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_tool_bash_20241022.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaToolBash20241022 = Beta::BetaToolBash20241022
+
+    module Beta
+      class BetaToolBash20241022 < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaToolBash20241022,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # Name of the tool.
+        #
+        # This is how the tool will be called by the model and in `tool_use` blocks.
+        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(
+            cache_control:
+              T.nilable(Anthropic::Beta::BetaCacheControlEphemeral::OrHash),
+            name: Symbol,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Create a cache control breakpoint at this content block.
+          cache_control: nil,
+          # Name of the tool.
+          #
+          # This is how the tool will be called by the model and in `tool_use` blocks.
+          name: :bash,
+          type: :bash_20241022
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              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_tool_bash_20250124.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaToolBash20250124 = Beta::BetaToolBash20250124
+
+    module Beta
+      class BetaToolBash20250124 < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaToolBash20250124,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # Name of the tool.
+        #
+        # This is how the tool will be called by the model and in `tool_use` blocks.
+        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(
+            cache_control:
+              T.nilable(Anthropic::Beta::BetaCacheControlEphemeral::OrHash),
+            name: Symbol,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Create a cache control breakpoint at this content block.
+          cache_control: nil,
+          # Name of the tool.
+          #
+          # This is how the tool will be called by the model and in `tool_use` blocks.
+          name: :bash,
+          type: :bash_20250124
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              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_tool_choice.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaToolChoice = Beta::BetaToolChoice
+
+    module Beta
+      # How the model should use the provided tools. The model can use a specific tool,
+      # any available tool, decide by itself, or not use tools at all.
+      module BetaToolChoice
+        extend Anthropic::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaToolChoiceAuto,
+              Anthropic::Beta::BetaToolChoiceAny,
+              Anthropic::Beta::BetaToolChoiceTool,
+              Anthropic::Beta::BetaToolChoiceNone
+            )
+          end
+
+        sig do
+          override.returns(T::Array[Anthropic::Beta::BetaToolChoice::Variants])
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_tool_choice_any.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaToolChoiceAny = Beta::BetaToolChoiceAny
+
+    module Beta
+      class BetaToolChoiceAny < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaToolChoiceAny,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Whether to disable parallel tool use.
+        #
+        # Defaults to `false`. If set to `true`, the model will output exactly one tool
+        # use.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :disable_parallel_tool_use
+
+        sig { params(disable_parallel_tool_use: T::Boolean).void }
+        attr_writer :disable_parallel_tool_use
+
+        # The model will use any available tools.
+        sig do
+          params(disable_parallel_tool_use: T::Boolean, type: Symbol).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # Whether to disable parallel tool use.
+          #
+          # Defaults to `false`. If set to `true`, the model will output exactly one tool
+          # use.
+          disable_parallel_tool_use: nil,
+          type: :any
+        )
+        end
+
+        sig do
+          override.returns(
+            { type: Symbol, disable_parallel_tool_use: T::Boolean }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end