anthropic-sdk-beta 0.1.0.pre.beta.6 → 0.1.0.pre.beta.7

data/rbi/anthropic/models/text_block_param.rbi

@@ -0,0 +1,95 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class TextBlockParam < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::TextBlockParam, Anthropic::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :text
+
+      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
+        returns(
+          T.nilable(
+            T::Array[
+              T.any(
+                Anthropic::CitationCharLocationParam,
+                Anthropic::CitationPageLocationParam,
+                Anthropic::CitationContentBlockLocationParam,
+                Anthropic::CitationWebSearchResultLocationParam
+              )
+            ]
+          )
+        )
+      end
+      attr_accessor :citations
+
+      sig do
+        params(
+          text: String,
+          cache_control: T.nilable(Anthropic::CacheControlEphemeral::OrHash),
+          citations:
+            T.nilable(
+              T::Array[
+                T.any(
+                  Anthropic::CitationCharLocationParam::OrHash,
+                  Anthropic::CitationPageLocationParam::OrHash,
+                  Anthropic::CitationContentBlockLocationParam::OrHash,
+                  Anthropic::CitationWebSearchResultLocationParam::OrHash
+                )
+              ]
+            ),
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        text:,
+        # Create a cache control breakpoint at this content block.
+        cache_control: nil,
+        citations: nil,
+        type: :text
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            text: String,
+            type: Symbol,
+            cache_control: T.nilable(Anthropic::CacheControlEphemeral),
+            citations:
+              T.nilable(
+                T::Array[
+                  T.any(
+                    Anthropic::CitationCharLocationParam,
+                    Anthropic::CitationPageLocationParam,
+                    Anthropic::CitationContentBlockLocationParam,
+                    Anthropic::CitationWebSearchResultLocationParam
+                  )
+                ]
+              )
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/text_citation.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module TextCitation
+      extend Anthropic::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Anthropic::CitationCharLocation,
+            Anthropic::CitationPageLocation,
+            Anthropic::CitationContentBlockLocation,
+            Anthropic::CitationsWebSearchResultLocation
+          )
+        end
+
+      sig { override.returns(T::Array[Anthropic::TextCitation::Variants]) }
+      def self.variants
+      end
+    end
+  end
+end

data/rbi/anthropic/models/text_citation_param.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module TextCitationParam
+      extend Anthropic::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Anthropic::CitationCharLocationParam,
+            Anthropic::CitationPageLocationParam,
+            Anthropic::CitationContentBlockLocationParam,
+            Anthropic::CitationWebSearchResultLocationParam
+          )
+        end
+
+      sig { override.returns(T::Array[Anthropic::TextCitationParam::Variants]) }
+      def self.variants
+      end
+    end
+  end
+end

data/rbi/{lib/anthropic → anthropic}/models/text_delta.rbi

@@ -3,6 +3,11 @@
 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
 
@@ -10,10 +15,12 @@ module Anthropic
       attr_accessor :type
 
       sig { params(text: String, type: Symbol).returns(T.attached_class) }
-      def self.new(text:, type: :text_delta); end
+      def self.new(text:, type: :text_delta)
+      end
 
-      sig { override.returns({text: String, type: Symbol}) }
-      def to_hash; end
+      sig { override.returns({ text: String, type: Symbol }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/anthropic/models/thinking_block.rbi

@@ -0,0 +1,35 @@
+# 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

@@ -0,0 +1,35 @@
+# 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/{lib/anthropic → anthropic}/models/thinking_config_disabled.rbi

@@ -3,14 +3,21 @@
 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
+      def self.new(type: :disabled)
+      end
 
-      sig { override.returns({type: Symbol}) }
-      def to_hash; end
+      sig { override.returns({ type: Symbol }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/anthropic/models/thinking_config_enabled.rbi

@@ -0,0 +1,49 @@
+# 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/{lib/anthropic → anthropic}/models/thinking_config_param.rbi

@@ -14,8 +14,19 @@ module Anthropic
     module ThinkingConfigParam
       extend Anthropic::Internal::Type::Union
 
-      sig { override.returns([Anthropic::Models::ThinkingConfigEnabled, Anthropic::Models::ThinkingConfigDisabled]) }
-      def self.variants; end
+      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/{lib/anthropic → anthropic}/models/thinking_delta.rbi

@@ -3,6 +3,11 @@
 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
 
@@ -10,10 +15,12 @@ module Anthropic
       attr_accessor :type
 
       sig { params(thinking: String, type: Symbol).returns(T.attached_class) }
-      def self.new(thinking:, type: :thinking_delta); end
+      def self.new(thinking:, type: :thinking_delta)
+      end
 
-      sig { override.returns({thinking: String, type: Symbol}) }
-      def to_hash; end
+      sig { override.returns({ thinking: String, type: Symbol }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/anthropic/models/tool.rbi

@@ -0,0 +1,142 @@
+# 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

@@ -0,0 +1,62 @@
+# 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

@@ -0,0 +1,25 @@
+# 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

@@ -0,0 +1,49 @@
+# 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

@@ -0,0 +1,49 @@
+# 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