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

data/rbi/anthropic/models/raw_content_block_start_event.rbi

@@ -0,0 +1,99 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class RawContentBlockStartEvent < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::RawContentBlockStartEvent,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      sig do
+        returns(
+          T.any(
+            Anthropic::TextBlock,
+            Anthropic::ToolUseBlock,
+            Anthropic::ServerToolUseBlock,
+            Anthropic::WebSearchToolResultBlock,
+            Anthropic::ThinkingBlock,
+            Anthropic::RedactedThinkingBlock
+          )
+        )
+      end
+      attr_accessor :content_block
+
+      sig { returns(Integer) }
+      attr_accessor :index
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+          content_block:
+            T.any(
+              Anthropic::TextBlock::OrHash,
+              Anthropic::ToolUseBlock::OrHash,
+              Anthropic::ServerToolUseBlock::OrHash,
+              Anthropic::WebSearchToolResultBlock::OrHash,
+              Anthropic::ThinkingBlock::OrHash,
+              Anthropic::RedactedThinkingBlock::OrHash
+            ),
+          index: Integer,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(content_block:, index:, type: :content_block_start)
+      end
+
+      sig do
+        override.returns(
+          {
+            content_block:
+              T.any(
+                Anthropic::TextBlock,
+                Anthropic::ToolUseBlock,
+                Anthropic::ServerToolUseBlock,
+                Anthropic::WebSearchToolResultBlock,
+                Anthropic::ThinkingBlock,
+                Anthropic::RedactedThinkingBlock
+              ),
+            index: Integer,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module ContentBlock
+        extend Anthropic::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Anthropic::TextBlock,
+              Anthropic::ToolUseBlock,
+              Anthropic::ServerToolUseBlock,
+              Anthropic::WebSearchToolResultBlock,
+              Anthropic::ThinkingBlock,
+              Anthropic::RedactedThinkingBlock
+            )
+          end
+
+        sig do
+          override.returns(
+            T::Array[
+              Anthropic::RawContentBlockStartEvent::ContentBlock::Variants
+            ]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

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

@@ -3,6 +3,14 @@
 module Anthropic
   module Models
     class RawContentBlockStopEvent < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::RawContentBlockStopEvent,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
       sig { returns(Integer) }
       attr_accessor :index
 
@@ -10,10 +18,12 @@ module Anthropic
       attr_accessor :type
 
       sig { params(index: Integer, type: Symbol).returns(T.attached_class) }
-      def self.new(index:, type: :content_block_stop); end
+      def self.new(index:, type: :content_block_stop)
+      end
 
-      sig { override.returns({index: Integer, type: Symbol}) }
-      def to_hash; end
+      sig { override.returns({ index: Integer, type: Symbol }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/anthropic/models/raw_message_delta_event.rbi

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

data/rbi/anthropic/models/raw_message_start_event.rbi

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

data/rbi/anthropic/models/raw_message_stop_event.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class RawMessageStopEvent < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::RawMessageStopEvent, Anthropic::Internal::AnyHash)
+        end
+
+      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/anthropic/models/raw_message_stream_event.rbi

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

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

@@ -3,6 +3,11 @@
 module Anthropic
   module Models
     class RedactedThinkingBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::RedactedThinkingBlock, Anthropic::Internal::AnyHash)
+        end
+
       sig { returns(String) }
       attr_accessor :data
 
@@ -10,10 +15,12 @@ module Anthropic
       attr_accessor :type
 
       sig { params(data: String, type: Symbol).returns(T.attached_class) }
-      def self.new(data:, type: :redacted_thinking); end
+      def self.new(data:, type: :redacted_thinking)
+      end
 
-      sig { override.returns({data: String, type: Symbol}) }
-      def to_hash; end
+      sig { override.returns({ data: String, type: Symbol }) }
+      def to_hash
+      end
     end
   end
 end

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

@@ -3,6 +3,14 @@
 module Anthropic
   module Models
     class RedactedThinkingBlockParam < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::RedactedThinkingBlockParam,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
       sig { returns(String) }
       attr_accessor :data
 
@@ -10,10 +18,12 @@ module Anthropic
       attr_accessor :type
 
       sig { params(data: String, type: Symbol).returns(T.attached_class) }
-      def self.new(data:, type: :redacted_thinking); end
+      def self.new(data:, type: :redacted_thinking)
+      end
 
-      sig { override.returns({data: String, type: Symbol}) }
-      def to_hash; end
+      sig { override.returns({ data: String, type: Symbol }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/anthropic/models/server_tool_usage.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ServerToolUsage < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::ServerToolUsage, Anthropic::Internal::AnyHash)
+        end
+
+      # The number of web search tool requests.
+      sig { returns(Integer) }
+      attr_accessor :web_search_requests
+
+      sig { params(web_search_requests: Integer).returns(T.attached_class) }
+      def self.new(
+        # The number of web search tool requests.
+        web_search_requests:
+      )
+      end
+
+      sig { override.returns({ web_search_requests: Integer }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/server_tool_use_block.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ServerToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::ServerToolUseBlock, Anthropic::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(T.anything) }
+      attr_accessor :input
+
+      sig { returns(Symbol) }
+      attr_accessor :name
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+          id: String,
+          input: T.anything,
+          name: Symbol,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(id:, input:, name: :web_search, type: :server_tool_use)
+      end
+
+      sig do
+        override.returns(
+          { id: String, input: T.anything, name: Symbol, type: Symbol }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/server_tool_use_block_param.rbi

@@ -0,0 +1,71 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ServerToolUseBlockParam < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ServerToolUseBlockParam,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(T.anything) }
+      attr_accessor :input
+
+      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(
+          id: String,
+          input: T.anything,
+          cache_control: T.nilable(Anthropic::CacheControlEphemeral::OrHash),
+          name: Symbol,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        input:,
+        # Create a cache control breakpoint at this content block.
+        cache_control: nil,
+        name: :web_search,
+        type: :server_tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            input: T.anything,
+            name: Symbol,
+            type: Symbol,
+            cache_control: T.nilable(Anthropic::CacheControlEphemeral)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

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

@@ -3,6 +3,11 @@
 module Anthropic
   module Models
     class SignatureDelta < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::SignatureDelta, Anthropic::Internal::AnyHash)
+        end
+
       sig { returns(String) }
       attr_accessor :signature
 
@@ -10,10 +15,12 @@ module Anthropic
       attr_accessor :type
 
       sig { params(signature: String, type: Symbol).returns(T.attached_class) }
-      def self.new(signature:, type: :signature_delta); end
+      def self.new(signature:, type: :signature_delta)
+      end
 
-      sig { override.returns({signature: String, type: Symbol}) }
-      def to_hash; end
+      sig { override.returns({ signature: String, type: Symbol }) }
+      def to_hash
+      end
     end
   end
 end

data/rbi/anthropic/models/stop_reason.rbi

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

data/rbi/anthropic/models/text_block.rbi

@@ -0,0 +1,90 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class TextBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::TextBlock, Anthropic::Internal::AnyHash)
+        end
+
+      # 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::CitationCharLocation,
+                Anthropic::CitationPageLocation,
+                Anthropic::CitationContentBlockLocation,
+                Anthropic::CitationsWebSearchResultLocation
+              )
+            ]
+          )
+        )
+      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::CitationCharLocation::OrHash,
+                  Anthropic::CitationPageLocation::OrHash,
+                  Anthropic::CitationContentBlockLocation::OrHash,
+                  Anthropic::CitationsWebSearchResultLocation::OrHash
+                )
+              ]
+            ),
+          text: String,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # 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`.
+        citations:,
+        text:,
+        type: :text
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            citations:
+              T.nilable(
+                T::Array[
+                  T.any(
+                    Anthropic::CitationCharLocation,
+                    Anthropic::CitationPageLocation,
+                    Anthropic::CitationContentBlockLocation,
+                    Anthropic::CitationsWebSearchResultLocation
+                  )
+                ]
+              ),
+            text: String,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end