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

data/rbi/lib/anthropic/models/raw_message_delta_event.rbi

@@ -1,81 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class RawMessageDeltaEvent < Anthropic::Internal::Type::BaseModel
-      sig { returns(Anthropic::Models::RawMessageDeltaEvent::Delta) }
-      attr_reader :delta
-
-      sig { params(delta: T.any(Anthropic::Models::RawMessageDeltaEvent::Delta, Anthropic::Internal::AnyHash)).void }
-      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::Models::MessageDeltaUsage) }
-      attr_reader :usage
-
-      sig { params(usage: T.any(Anthropic::Models::MessageDeltaUsage, Anthropic::Internal::AnyHash)).void }
-      attr_writer :usage
-
-      sig do
-        params(
-          delta: T.any(Anthropic::Models::RawMessageDeltaEvent::Delta, Anthropic::Internal::AnyHash),
-          usage: T.any(Anthropic::Models::MessageDeltaUsage, Anthropic::Internal::AnyHash),
-          type: Symbol
-        )
-          .returns(T.attached_class)
-      end
-      def self.new(delta:, usage:, type: :message_delta); end
-
-      sig do
-        override
-          .returns(
-            {
-              delta: Anthropic::Models::RawMessageDeltaEvent::Delta,
-              type: Symbol,
-              usage: Anthropic::Models::MessageDeltaUsage
-            }
-          )
-      end
-      def to_hash; end
-
-      class Delta < Anthropic::Internal::Type::BaseModel
-        sig { returns(T.nilable(Anthropic::Models::StopReason::TaggedSymbol)) }
-        attr_accessor :stop_reason
-
-        sig { returns(T.nilable(String)) }
-        attr_accessor :stop_sequence
-
-        sig do
-          params(stop_reason: T.nilable(Anthropic::Models::StopReason::OrSymbol), stop_sequence: T.nilable(String))
-            .returns(T.attached_class)
-        end
-        def self.new(stop_reason:, stop_sequence:); end
-
-        sig do
-          override
-            .returns(
-              {stop_reason: T.nilable(Anthropic::Models::StopReason::TaggedSymbol), stop_sequence: T.nilable(String)}
-            )
-        end
-        def to_hash; end
-      end
-    end
-  end
-end

data/rbi/lib/anthropic/models/raw_message_start_event.rbi

@@ -1,25 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class RawMessageStartEvent < Anthropic::Internal::Type::BaseModel
-      sig { returns(Anthropic::Models::Message) }
-      attr_reader :message
-
-      sig { params(message: T.any(Anthropic::Models::Message, Anthropic::Internal::AnyHash)).void }
-      attr_writer :message
-
-      sig { returns(Symbol) }
-      attr_accessor :type
-
-      sig do
-        params(message: T.any(Anthropic::Models::Message, Anthropic::Internal::AnyHash), type: Symbol)
-          .returns(T.attached_class)
-      end
-      def self.new(message:, type: :message_start); end
-
-      sig { override.returns({message: Anthropic::Models::Message, type: Symbol}) }
-      def to_hash; end
-    end
-  end
-end

data/rbi/lib/anthropic/models/raw_message_stop_event.rbi

@@ -1,16 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class RawMessageStopEvent < Anthropic::Internal::Type::BaseModel
-      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

data/rbi/lib/anthropic/models/raw_message_stream_event.rbi

@@ -1,17 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    module RawMessageStreamEvent
-      extend Anthropic::Internal::Type::Union
-
-      sig do
-        override
-          .returns(
-            [Anthropic::Models::RawMessageStartEvent, Anthropic::Models::RawMessageDeltaEvent, Anthropic::Models::RawMessageStopEvent, Anthropic::Models::RawContentBlockStartEvent, Anthropic::Models::RawContentBlockDeltaEvent, Anthropic::Models::RawContentBlockStopEvent]
-          )
-      end
-      def self.variants; end
-    end
-  end
-end

data/rbi/lib/anthropic/models/stop_reason.rbi

@@ -1,20 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    module StopReason
-      extend Anthropic::Internal::Type::Enum
-
-      TaggedSymbol = T.type_alias { T.all(Symbol, Anthropic::Models::StopReason) }
-      OrSymbol = T.type_alias { T.any(Symbol, String, Anthropic::Models::StopReason::TaggedSymbol) }
-
-      END_TURN = T.let(:end_turn, Anthropic::Models::StopReason::TaggedSymbol)
-      MAX_TOKENS = T.let(:max_tokens, Anthropic::Models::StopReason::TaggedSymbol)
-      STOP_SEQUENCE = T.let(:stop_sequence, Anthropic::Models::StopReason::TaggedSymbol)
-      TOOL_USE = T.let(:tool_use, Anthropic::Models::StopReason::TaggedSymbol)
-
-      sig { override.returns(T::Array[Anthropic::Models::StopReason::TaggedSymbol]) }
-      def self.values; end
-    end
-  end
-end

data/rbi/lib/anthropic/models/text_block.rbi

@@ -1,72 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class TextBlock < Anthropic::Internal::Type::BaseModel
-      # Citations supporting the text block.
-      #
-      # The type of citation returned will depend on the type of document being cited.
-      # Citing a PDF results in `page_location`, plain text results in `char_location`,
-      # and content document results in `content_block_location`.
-      sig do
-        returns(
-          T.nilable(
-            T::Array[
-              T.any(
-                Anthropic::Models::CitationCharLocation,
-                Anthropic::Models::CitationPageLocation,
-                Anthropic::Models::CitationContentBlockLocation
-              )
-            ]
-          )
-        )
-      end
-      attr_accessor :citations
-
-      sig { returns(String) }
-      attr_accessor :text
-
-      sig { returns(Symbol) }
-      attr_accessor :type
-
-      sig do
-        params(
-          citations: T.nilable(
-            T::Array[
-              T.any(
-                Anthropic::Models::CitationCharLocation,
-                Anthropic::Internal::AnyHash,
-                Anthropic::Models::CitationPageLocation,
-                Anthropic::Models::CitationContentBlockLocation
-              )
-            ]
-          ),
-          text: String,
-          type: Symbol
-        )
-          .returns(T.attached_class)
-      end
-      def self.new(citations:, text:, type: :text); end
-
-      sig do
-        override
-          .returns(
-            {
-              citations: T.nilable(
-                T::Array[
-                  T.any(
-                    Anthropic::Models::CitationCharLocation,
-                    Anthropic::Models::CitationPageLocation,
-                    Anthropic::Models::CitationContentBlockLocation
-                  )
-                ]
-              ),
-              text: String,
-              type: Symbol
-            }
-          )
-      end
-      def to_hash; end
-    end
-  end
-end

data/rbi/lib/anthropic/models/text_block_param.rbi

@@ -1,80 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Models
-    class TextBlockParam < Anthropic::Internal::Type::BaseModel
-      sig { returns(String) }
-      attr_accessor :text
-
-      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::Array[
-              T.any(
-                Anthropic::Models::CitationCharLocationParam,
-                Anthropic::Models::CitationPageLocationParam,
-                Anthropic::Models::CitationContentBlockLocationParam
-              )
-            ]
-          )
-        )
-      end
-      attr_accessor :citations
-
-      sig do
-        params(
-          text: String,
-          cache_control: T.nilable(T.any(Anthropic::Models::CacheControlEphemeral, Anthropic::Internal::AnyHash)),
-          citations: T.nilable(
-            T::Array[
-              T.any(
-                Anthropic::Models::CitationCharLocationParam,
-                Anthropic::Internal::AnyHash,
-                Anthropic::Models::CitationPageLocationParam,
-                Anthropic::Models::CitationContentBlockLocationParam
-              )
-            ]
-          ),
-          type: Symbol
-        )
-          .returns(T.attached_class)
-      end
-      def self.new(text:, cache_control: nil, citations: nil, type: :text); end
-
-      sig do
-        override
-          .returns(
-            {
-              text: String,
-              type: Symbol,
-              cache_control: T.nilable(Anthropic::Models::CacheControlEphemeral),
-              citations: T.nilable(
-                T::Array[
-                  T.any(
-                    Anthropic::Models::CitationCharLocationParam,
-                    Anthropic::Models::CitationPageLocationParam,
-                    Anthropic::Models::CitationContentBlockLocationParam
-                  )
-                ]
-              )
-            }
-          )
-      end
-      def to_hash; end
-    end
-  end
-end

data/rbi/lib/anthropic/models/text_citation.rbi

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

data/rbi/lib/anthropic/models/text_citation_param.rbi

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

data/rbi/lib/anthropic/models/thinking_block.rbi

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

data/rbi/lib/anthropic/models/thinking_block_param.rbi

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

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

@@ -1,28 +0,0 @@
-# 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/tool.rbi

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

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

@@ -1,19 +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
-
-      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

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

@@ -1,27 +0,0 @@
-# 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_tool.rbi

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