anthropic-sdk-beta 0.1.0.pre.beta.3

data/rbi/lib/anthropic/models/thinking_config_enabled.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ThinkingConfigEnabled < Anthropic::Internal::Type::BaseModel
+      # 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 { params(budget_tokens: Integer, type: Symbol).returns(T.attached_class) }
+      def self.new(budget_tokens:, type: :enabled); end
+
+      sig { override.returns({budget_tokens: Integer, type: Symbol}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/thinking_config_param.rbi

@@ -0,0 +1,21 @@
+# 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
+
+      sig { override.returns([Anthropic::Models::ThinkingConfigEnabled, Anthropic::Models::ThinkingConfigDisabled]) }
+      def self.variants; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/thinking_delta.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ThinkingDelta < Anthropic::Internal::Type::BaseModel
+      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/lib/anthropic/models/tool.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class Tool < Anthropic::Internal::Type::BaseModel
+      # [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::Models::Tool::InputSchema) }
+      attr_reader :input_schema
+
+      sig { params(input_schema: T.any(Anthropic::Models::Tool::InputSchema, Anthropic::Internal::AnyHash)).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
+
+      sig { returns(T.nilable(Anthropic::Models::CacheControlEphemeral)) }
+      attr_reader :cache_control
+
+      sig do
+        params(
+          cache_control: T.nilable(T.any(Anthropic::Models::CacheControlEphemeral, Anthropic::Internal::AnyHash))
+        )
+          .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 do
+        params(
+          input_schema: T.any(Anthropic::Models::Tool::InputSchema, Anthropic::Internal::AnyHash),
+          name: String,
+          cache_control: T.nilable(T.any(Anthropic::Models::CacheControlEphemeral, Anthropic::Internal::AnyHash)),
+          description: String
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(input_schema:, name:, cache_control: nil, description: nil); end
+
+      sig do
+        override
+          .returns(
+            {
+              input_schema: Anthropic::Models::Tool::InputSchema,
+              name: String,
+              cache_control: T.nilable(Anthropic::Models::CacheControlEphemeral),
+              description: String
+            }
+          )
+      end
+      def to_hash; end
+
+      class InputSchema < Anthropic::Internal::Type::BaseModel
+        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 { params(properties: T.nilable(T.anything), type: Symbol).returns(T.attached_class) }
+        def self.new(properties: nil, type: :object); end
+
+        sig { override.returns({type: Symbol, properties: T.nilable(T.anything)}) }
+        def to_hash; end
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/tool_bash_20250124.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ToolBash20250124 < Anthropic::Internal::Type::BaseModel
+      # 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
+
+      sig { returns(T.nilable(Anthropic::Models::CacheControlEphemeral)) }
+      attr_reader :cache_control
+
+      sig do
+        params(
+          cache_control: T.nilable(T.any(Anthropic::Models::CacheControlEphemeral, Anthropic::Internal::AnyHash))
+        )
+          .void
+      end
+      attr_writer :cache_control
+
+      sig do
+        params(
+          cache_control: T.nilable(T.any(Anthropic::Models::CacheControlEphemeral, Anthropic::Internal::AnyHash)),
+          name: Symbol,
+          type: Symbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(cache_control: nil, name: :bash, type: :bash_20250124); end
+
+      sig do
+        override
+          .returns({name: Symbol, type: Symbol, cache_control: T.nilable(Anthropic::Models::CacheControlEphemeral)})
+      end
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/tool_choice.rbi

@@ -0,0 +1,19 @@
+# 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
+
+      sig do
+        override
+          .returns(
+            [Anthropic::Models::ToolChoiceAuto, Anthropic::Models::ToolChoiceAny, Anthropic::Models::ToolChoiceTool, Anthropic::Models::ToolChoiceNone]
+          )
+      end
+      def self.variants; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/tool_choice_any.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ToolChoiceAny < Anthropic::Internal::Type::BaseModel
+      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 { params(disable_parallel_tool_use: T::Boolean, type: Symbol).returns(T.attached_class) }
+      def self.new(disable_parallel_tool_use: nil, type: :any); end
+
+      sig { override.returns({type: Symbol, disable_parallel_tool_use: T::Boolean}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/tool_choice_auto.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ToolChoiceAuto < Anthropic::Internal::Type::BaseModel
+      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 { params(disable_parallel_tool_use: T::Boolean, type: Symbol).returns(T.attached_class) }
+      def self.new(disable_parallel_tool_use: nil, type: :auto); end
+
+      sig { override.returns({type: Symbol, disable_parallel_tool_use: T::Boolean}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/tool_choice_none.rbi

@@ -0,0 +1,17 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ToolChoiceNone < Anthropic::Internal::Type::BaseModel
+      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/lib/anthropic/models/tool_choice_tool.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ToolChoiceTool < Anthropic::Internal::Type::BaseModel
+      # 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(name:, disable_parallel_tool_use: nil, type: :tool); end
+
+      sig { override.returns({name: String, type: Symbol, disable_parallel_tool_use: T::Boolean}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/tool_result_block_param.rbi

@@ -0,0 +1,102 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ToolResultBlockParam < Anthropic::Internal::Type::BaseModel
+      sig { returns(String) }
+      attr_accessor :tool_use_id
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(Anthropic::Models::CacheControlEphemeral)) }
+      attr_reader :cache_control
+
+      sig do
+        params(
+          cache_control: T.nilable(T.any(Anthropic::Models::CacheControlEphemeral, Anthropic::Internal::AnyHash))
+        )
+          .void
+      end
+      attr_writer :cache_control
+
+      sig do
+        returns(
+          T.nilable(
+            T.any(String, T::Array[T.any(Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam)])
+          )
+        )
+      end
+      attr_reader :content
+
+      sig do
+        params(
+          content: T.any(
+            String,
+            T::Array[T.any(Anthropic::Models::TextBlockParam, Anthropic::Internal::AnyHash, Anthropic::Models::ImageBlockParam)]
+          )
+        )
+          .void
+      end
+      attr_writer :content
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :is_error
+
+      sig { params(is_error: T::Boolean).void }
+      attr_writer :is_error
+
+      sig do
+        params(
+          tool_use_id: String,
+          cache_control: T.nilable(T.any(Anthropic::Models::CacheControlEphemeral, Anthropic::Internal::AnyHash)),
+          content: T.any(
+            String,
+            T::Array[T.any(Anthropic::Models::TextBlockParam, Anthropic::Internal::AnyHash, Anthropic::Models::ImageBlockParam)]
+          ),
+          is_error: T::Boolean,
+          type: Symbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(tool_use_id:, cache_control: nil, content: nil, is_error: nil, type: :tool_result); end
+
+      sig do
+        override
+          .returns(
+            {
+              tool_use_id: String,
+              type: Symbol,
+              cache_control: T.nilable(Anthropic::Models::CacheControlEphemeral),
+              content: T.any(String, T::Array[T.any(Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam)]),
+              is_error: T::Boolean
+            }
+          )
+      end
+      def to_hash; end
+
+      module Content
+        extend Anthropic::Internal::Type::Union
+
+        module Content
+          extend Anthropic::Internal::Type::Union
+
+          sig { override.returns([Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam]) }
+          def self.variants; end
+        end
+
+        sig do
+          override
+            .returns([String, T::Array[T.any(Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam)]])
+        end
+        def self.variants; end
+
+        ContentArray =
+          T.let(
+            Anthropic::Internal::Type::ArrayOf[union: Anthropic::Models::ToolResultBlockParam::Content::Content],
+            Anthropic::Internal::Type::Converter
+          )
+      end
+    end
+  end
+end

data/rbi/lib/anthropic/models/tool_text_editor_20250124.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ToolTextEditor20250124 < Anthropic::Internal::Type::BaseModel
+      # 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
+
+      sig { returns(T.nilable(Anthropic::Models::CacheControlEphemeral)) }
+      attr_reader :cache_control
+
+      sig do
+        params(
+          cache_control: T.nilable(T.any(Anthropic::Models::CacheControlEphemeral, Anthropic::Internal::AnyHash))
+        )
+          .void
+      end
+      attr_writer :cache_control
+
+      sig do
+        params(
+          cache_control: T.nilable(T.any(Anthropic::Models::CacheControlEphemeral, Anthropic::Internal::AnyHash)),
+          name: Symbol,
+          type: Symbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(cache_control: nil, name: :str_replace_editor, type: :text_editor_20250124); end
+
+      sig do
+        override
+          .returns({name: Symbol, type: Symbol, cache_control: T.nilable(Anthropic::Models::CacheControlEphemeral)})
+      end
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/tool_union.rbi

@@ -0,0 +1,17 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module ToolUnion
+      extend Anthropic::Internal::Type::Union
+
+      sig do
+        override
+          .returns(
+            [Anthropic::Models::Tool, Anthropic::Models::ToolBash20250124, Anthropic::Models::ToolTextEditor20250124]
+          )
+      end
+      def self.variants; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/tool_use_block.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ToolUseBlock < Anthropic::Internal::Type::BaseModel
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(T.anything) }
+      attr_accessor :input
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig { params(id: String, input: T.anything, name: String, type: Symbol).returns(T.attached_class) }
+      def self.new(id:, input:, name:, type: :tool_use); end
+
+      sig { override.returns({id: String, input: T.anything, name: String, type: Symbol}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/tool_use_block_param.rbi

@@ -0,0 +1,56 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ToolUseBlockParam < Anthropic::Internal::Type::BaseModel
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(T.anything) }
+      attr_accessor :input
+
+      sig { returns(String) }
+      attr_accessor :name
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig { returns(T.nilable(Anthropic::Models::CacheControlEphemeral)) }
+      attr_reader :cache_control
+
+      sig do
+        params(
+          cache_control: T.nilable(T.any(Anthropic::Models::CacheControlEphemeral, Anthropic::Internal::AnyHash))
+        )
+          .void
+      end
+      attr_writer :cache_control
+
+      sig do
+        params(
+          id: String,
+          input: T.anything,
+          name: String,
+          cache_control: T.nilable(T.any(Anthropic::Models::CacheControlEphemeral, Anthropic::Internal::AnyHash)),
+          type: Symbol
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(id:, input:, name:, cache_control: nil, type: :tool_use); end
+
+      sig do
+        override
+          .returns(
+            {
+              id: String,
+              input: T.anything,
+              name: String,
+              type: Symbol,
+              cache_control: T.nilable(Anthropic::Models::CacheControlEphemeral)
+            }
+          )
+      end
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/url_image_source.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class URLImageSource < Anthropic::Internal::Type::BaseModel
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig { returns(String) }
+      attr_accessor :url
+
+      sig { params(url: String, type: Symbol).returns(T.attached_class) }
+      def self.new(url:, type: :url); end
+
+      sig { override.returns({type: Symbol, url: String}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/url_pdf_source.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class URLPDFSource < Anthropic::Internal::Type::BaseModel
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig { returns(String) }
+      attr_accessor :url
+
+      sig { params(url: String, type: Symbol).returns(T.attached_class) }
+      def self.new(url:, type: :url); end
+
+      sig { override.returns({type: Symbol, url: String}) }
+      def to_hash; end
+    end
+  end
+end

data/rbi/lib/anthropic/models/usage.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class Usage < Anthropic::Internal::Type::BaseModel
+      # The number of input tokens used to create the cache entry.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :cache_creation_input_tokens
+
+      # The number of input tokens read from the cache.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :cache_read_input_tokens
+
+      # The number of input tokens which were used.
+      sig { returns(Integer) }
+      attr_accessor :input_tokens
+
+      # The number of output tokens which were used.
+      sig { returns(Integer) }
+      attr_accessor :output_tokens
+
+      sig do
+        params(
+          cache_creation_input_tokens: T.nilable(Integer),
+          cache_read_input_tokens: T.nilable(Integer),
+          input_tokens: Integer,
+          output_tokens: Integer
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(cache_creation_input_tokens:, cache_read_input_tokens:, input_tokens:, output_tokens:); end
+
+      sig do
+        override
+          .returns(
+            {
+              cache_creation_input_tokens: T.nilable(Integer),
+              cache_read_input_tokens: T.nilable(Integer),
+              input_tokens: Integer,
+              output_tokens: Integer
+            }
+          )
+      end
+      def to_hash; end
+    end
+  end
+end