anthropic 0.1.0.pre.beta.9 → 0.1.0

data/rbi/anthropic/models/text_delta.rbi

@@ -1,26 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class TextDelta < Anthropic::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Anthropic::TextDelta, 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

data/rbi/anthropic/models/thinking_block.rbi

@@ -1,35 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class ThinkingBlock < Anthropic::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Anthropic::ThinkingBlock, 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

data/rbi/anthropic/models/thinking_block_param.rbi

@@ -1,35 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class ThinkingBlockParam < Anthropic::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Anthropic::ThinkingBlockParam, 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

data/rbi/anthropic/models/thinking_config_disabled.rbi

@@ -1,23 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class ThinkingConfigDisabled < Anthropic::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Anthropic::ThinkingConfigDisabled, 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

data/rbi/anthropic/models/thinking_config_enabled.rbi

@@ -1,49 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class ThinkingConfigEnabled < Anthropic::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Anthropic::ThinkingConfigEnabled, 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

data/rbi/anthropic/models/thinking_config_param.rbi

@@ -1,32 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    # 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 ThinkingConfigParam
-      extend Anthropic::Internal::Type::Union
-
-      Variants =
-        T.type_alias do
-          T.any(
-            Anthropic::ThinkingConfigEnabled,
-            Anthropic::ThinkingConfigDisabled
-          )
-        end
-
-      sig do
-        override.returns(T::Array[Anthropic::ThinkingConfigParam::Variants])
-      end
-      def self.variants
-      end
-    end
-  end
-end

data/rbi/anthropic/models/thinking_delta.rbi

@@ -1,26 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class ThinkingDelta < Anthropic::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Anthropic::ThinkingDelta, 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

data/rbi/anthropic/models/tool.rbi

@@ -1,142 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class Tool < Anthropic::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias { T.any(Anthropic::Tool, Anthropic::Internal::AnyHash) }
-
-      # [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::Tool::InputSchema) }
-      attr_reader :input_schema
-
-      sig { params(input_schema: Anthropic::Tool::InputSchema::OrHash).void }
-      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::CacheControlEphemeral)) }
-      attr_reader :cache_control
-
-      sig do
-        params(
-          cache_control: T.nilable(Anthropic::CacheControlEphemeral::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::Tool::Type::OrSymbol)) }
-      attr_accessor :type
-
-      sig do
-        params(
-          input_schema: Anthropic::Tool::InputSchema::OrHash,
-          name: String,
-          cache_control: T.nilable(Anthropic::CacheControlEphemeral::OrHash),
-          description: String,
-          type: T.nilable(Anthropic::Tool::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::Tool::InputSchema,
-            name: String,
-            cache_control: T.nilable(Anthropic::CacheControlEphemeral),
-            description: String,
-            type: T.nilable(Anthropic::Tool::Type::OrSymbol)
-          }
-        )
-      end
-      def to_hash
-      end
-
-      class InputSchema < Anthropic::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(Anthropic::Tool::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::Tool::Type) }
-        OrSymbol = T.type_alias { T.any(Symbol, String) }
-
-        CUSTOM = T.let(:custom, Anthropic::Tool::Type::TaggedSymbol)
-
-        sig { override.returns(T::Array[Anthropic::Tool::Type::TaggedSymbol]) }
-        def self.values
-        end
-      end
-    end
-  end
-end

data/rbi/anthropic/models/tool_bash_20250124.rbi

@@ -1,62 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class ToolBash20250124 < Anthropic::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Anthropic::ToolBash20250124, 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::CacheControlEphemeral)) }
-      attr_reader :cache_control
-
-      sig do
-        params(
-          cache_control: T.nilable(Anthropic::CacheControlEphemeral::OrHash)
-        ).void
-      end
-      attr_writer :cache_control
-
-      sig do
-        params(
-          cache_control: T.nilable(Anthropic::CacheControlEphemeral::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::CacheControlEphemeral)
-          }
-        )
-      end
-      def to_hash
-      end
-    end
-  end
-end

data/rbi/anthropic/models/tool_choice.rbi

@@ -1,25 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    # 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 ToolChoice
-      extend Anthropic::Internal::Type::Union
-
-      Variants =
-        T.type_alias do
-          T.any(
-            Anthropic::ToolChoiceAuto,
-            Anthropic::ToolChoiceAny,
-            Anthropic::ToolChoiceTool,
-            Anthropic::ToolChoiceNone
-          )
-        end
-
-      sig { override.returns(T::Array[Anthropic::ToolChoice::Variants]) }
-      def self.variants
-      end
-    end
-  end
-end

data/rbi/anthropic/models/tool_choice_any.rbi

@@ -1,49 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class ToolChoiceAny < Anthropic::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Anthropic::ToolChoiceAny, 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

data/rbi/anthropic/models/tool_choice_auto.rbi

@@ -1,49 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class ToolChoiceAuto < Anthropic::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Anthropic::ToolChoiceAuto, 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 at most 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 automatically decide whether to use 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 at most one tool
-        # use.
-        disable_parallel_tool_use: nil,
-        type: :auto
-      )
-      end
-
-      sig do
-        override.returns(
-          { type: Symbol, disable_parallel_tool_use: T::Boolean }
-        )
-      end
-      def to_hash
-      end
-    end
-  end
-end

data/rbi/anthropic/models/tool_choice_none.rbi

@@ -1,24 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class ToolChoiceNone < Anthropic::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Anthropic::ToolChoiceNone, Anthropic::Internal::AnyHash)
-        end
-
-      sig { returns(Symbol) }
-      attr_accessor :type
-
-      # The model will not be allowed to use tools.
-      sig { params(type: Symbol).returns(T.attached_class) }
-      def self.new(type: :none)
-      end
-
-      sig { override.returns({ type: Symbol }) }
-      def to_hash
-      end
-    end
-  end
-end

data/rbi/anthropic/models/tool_choice_tool.rbi

@@ -1,57 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class ToolChoiceTool < Anthropic::Internal::Type::BaseModel
-      OrHash =
-        T.type_alias do
-          T.any(Anthropic::ToolChoiceTool, Anthropic::Internal::AnyHash)
-        end
-
-      # The name of the tool to use.
-      sig { returns(String) }
-      attr_accessor :name
-
-      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 the specified tool with `tool_choice.name`.
-      sig do
-        params(
-          name: String,
-          disable_parallel_tool_use: T::Boolean,
-          type: Symbol
-        ).returns(T.attached_class)
-      end
-      def self.new(
-        # The name of the tool to use.
-        name:,
-        # 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: :tool
-      )
-      end
-
-      sig do
-        override.returns(
-          { name: String, type: Symbol, disable_parallel_tool_use: T::Boolean }
-        )
-      end
-      def to_hash
-      end
-    end
-  end
-end