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

data/rbi/lib/anthropic/internal/transport/base_client.rbi

@@ -1,204 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Transport
-      # @api private
-      class BaseClient
-        abstract!
-
-        RequestComponentsShape =
-          T.type_alias do
-            {
-              method: Symbol,
-              path: T.any(String, T::Array[String]),
-              query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]),
-              headers: T.nilable(
-                T::Hash[String,
-                        T.nilable(
-                          T.any(
-                            String,
-                            Integer,
-                            T::Array[T.nilable(T.any(String, Integer))]
-                          )
-                        )]
-              ),
-              body: T.nilable(T.anything),
-              unwrap: T.nilable(Symbol),
-              page: T.nilable(T::Class[Anthropic::Internal::Type::BasePage[Anthropic::Internal::Type::BaseModel]]),
-              stream: T.nilable(
-                T::Class[Anthropic::Internal::Type::BaseStream[T.anything,
-                                                               Anthropic::Internal::Type::BaseModel]]
-              ),
-              model: T.nilable(Anthropic::Internal::Type::Converter::Input),
-              options: T.nilable(T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash))
-            }
-          end
-
-        RequestInputShape =
-          T.type_alias do
-            {
-              method: Symbol,
-              url: URI::Generic,
-              headers: T::Hash[String, String],
-              body: T.anything,
-              max_retries: Integer,
-              timeout: Float
-            }
-          end
-
-        # from whatwg fetch spec
-        MAX_REDIRECTS = 20
-
-        PLATFORM_HEADERS = T::Hash[String, String]
-
-        class << self
-          # @api private
-          sig { params(req: Anthropic::Internal::Transport::BaseClient::RequestComponentsShape).void }
-          def validate!(req); end
-
-          # @api private
-          sig do
-            params(
-              status: Integer,
-              headers: T.any(
-                T::Hash[String, String],
-                Net::HTTPHeader
-              )
-            ).returns(T::Boolean)
-          end
-          def should_retry?(status, headers:); end
-
-          # @api private
-          sig do
-            params(
-              request: Anthropic::Internal::Transport::BaseClient::RequestInputShape,
-              status: Integer,
-              response_headers: T.any(T::Hash[String, String], Net::HTTPHeader)
-            )
-              .returns(Anthropic::Internal::Transport::BaseClient::RequestInputShape)
-          end
-          def follow_redirect(request, status:, response_headers:); end
-
-          # @api private
-          sig do
-            params(
-              status: T.any(Integer, Anthropic::Errors::APIConnectionError),
-              stream: T.nilable(T::Enumerable[String])
-            )
-              .void
-          end
-          def reap_connection!(status, stream:); end
-        end
-
-        # @api private
-        sig { returns(Anthropic::Internal::Transport::PooledNetRequester) }
-        attr_accessor :requester
-
-        # @api private
-        sig do
-          params(
-            base_url: String,
-            timeout: Float,
-            max_retries: Integer,
-            initial_retry_delay: Float,
-            max_retry_delay: Float,
-            headers: T::Hash[String,
-                             T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))],
-            idempotency_header: T.nilable(String)
-          )
-            .returns(T.attached_class)
-        end
-        def self.new(
-          base_url:,
-          timeout: 0.0,
-          max_retries: 0,
-          initial_retry_delay: 0.0,
-          max_retry_delay: 0.0,
-          headers: {},
-          idempotency_header: nil
-        ); end
-        # @api private
-        sig { overridable.returns(T::Hash[String, String]) }
-        private def auth_headers; end
-
-        # @api private
-        sig { returns(String) }
-        private def generate_idempotency_key; end
-
-        # @api private
-        sig do
-          overridable
-            .params(
-              req: Anthropic::Internal::Transport::BaseClient::RequestComponentsShape,
-              opts: Anthropic::Internal::AnyHash
-            )
-            .returns(Anthropic::Internal::Transport::BaseClient::RequestInputShape)
-        end
-        private def build_request(req, opts); end
-
-        # @api private
-        sig { params(headers: T::Hash[String, String], retry_count: Integer).returns(Float) }
-        private def retry_delay(headers, retry_count:); end
-
-        # @api private
-        sig do
-          params(
-            request: Anthropic::Internal::Transport::BaseClient::RequestInputShape,
-            redirect_count: Integer,
-            retry_count: Integer,
-            send_retry_header: T::Boolean
-          )
-            .returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
-        end
-        private def send_request(request, redirect_count:, retry_count:, send_retry_header:); end
-
-        # Execute the request specified by `req`. This is the method that all resource
-        # methods call into.
-        #
-        # @overload request(method, path, query: {}, headers: {}, body: nil, unwrap: nil, page: nil, stream: nil, model: Anthropic::Internal::Type::Unknown, options: {})
-        sig do
-          params(
-            method: Symbol,
-            path: T.any(String, T::Array[String]),
-            query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]),
-            headers: T.nilable(
-              T::Hash[String,
-                      T.nilable(
-                        T.any(
-                          String,
-                          Integer,
-                          T::Array[T.nilable(T.any(String, Integer))]
-                        )
-                      )]
-            ),
-            body: T.nilable(T.anything),
-            unwrap: T.nilable(Symbol),
-            page: T.nilable(T::Class[Anthropic::Internal::Type::BasePage[Anthropic::Internal::Type::BaseModel]]),
-            stream: T.nilable(
-              T::Class[Anthropic::Internal::Type::BaseStream[T.anything,
-                                                             Anthropic::Internal::Type::BaseModel]]
-            ),
-            model: T.nilable(Anthropic::Internal::Type::Converter::Input),
-            options: T.nilable(T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash))
-          )
-            .returns(T.anything)
-        end
-        def request(
-          method,
-          path,
-          query: {},
-          headers: {},
-          body: nil,
-          unwrap: nil,
-          page: nil,
-          stream: nil,
-          model: Anthropic::Internal::Type::Unknown,
-          options: {}
-        ); end
-        sig { returns(String) }
-        def inspect; end
-      end
-    end
-  end
-end

data/rbi/lib/anthropic/internal/type/array_of.rbi

@@ -1,82 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      # @api private
-      #
-      # Array of items of a given type.
-      class ArrayOf
-        include Anthropic::Internal::Type::Converter
-
-        abstract!
-        final!
-
-        Elem = type_member(:out)
-
-        sig(:final) do
-          params(
-            type_info: T.any(
-              Anthropic::Internal::AnyHash,
-              T.proc.returns(Anthropic::Internal::Type::Converter::Input),
-              Anthropic::Internal::Type::Converter::Input
-            ),
-            spec: Anthropic::Internal::AnyHash
-          )
-            .returns(T.attached_class)
-        end
-        def self.[](type_info, spec = {}); end
-
-        sig(:final) { params(other: T.anything).returns(T::Boolean) }
-        def ===(other); end
-
-        sig(:final) { params(other: T.anything).returns(T::Boolean) }
-        def ==(other); end
-
-        # @api private
-        sig(:final) do
-          override
-            .params(
-              value: T.any(T::Array[T.anything], T.anything),
-              state: Anthropic::Internal::Type::Converter::CoerceState
-            )
-            .returns(T.any(T::Array[T.anything], T.anything))
-        end
-        def coerce(value, state:); end
-
-        # @api private
-        sig(:final) do
-          override
-            .params(
-              value: T.any(T::Array[T.anything], T.anything),
-              state: Anthropic::Internal::Type::Converter::DumpState
-            )
-            .returns(T.any(T::Array[T.anything], T.anything))
-        end
-        def dump(value, state:); end
-
-        # @api private
-        sig(:final) { returns(Elem) }
-        protected def item_type; end
-
-        # @api private
-        sig(:final) { returns(T::Boolean) }
-        protected def nilable?; end
-
-        # @api private
-        sig(:final) do
-          params(
-            type_info: T.any(
-              Anthropic::Internal::AnyHash,
-              T.proc.returns(Anthropic::Internal::Type::Converter::Input),
-              Anthropic::Internal::Type::Converter::Input
-            ),
-            spec: Anthropic::Internal::AnyHash
-          )
-            .void
-        end
-        def initialize(type_info, spec = {}); end
-      end
-    end
-  end
-end

data/rbi/lib/anthropic/internal/type/base_model.rbi

@@ -1,197 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      class BaseModel
-        extend Anthropic::Internal::Type::Converter
-
-        abstract!
-
-        KnownFieldShape = T.type_alias do
-          {mode: T.nilable(Symbol), required: T::Boolean, nilable: T::Boolean}
-        end
-
-        class << self
-          # @api private
-          #
-          # Assumes superclass fields are totally defined before fields are accessed /
-          # defined on subclasses.
-          sig do
-            returns(
-              T::Hash[
-                Symbol,
-                T.all(
-                  Anthropic::Internal::Type::BaseModel::KnownFieldShape,
-                  {type_fn: T.proc.returns(Anthropic::Internal::Type::Converter::Input)}
-                )
-              ]
-            )
-          end
-          def known_fields; end
-
-          # @api private
-          sig do
-            returns(
-              T::Hash[
-                Symbol,
-                T.all(
-                  Anthropic::Internal::Type::BaseModel::KnownFieldShape,
-                  {type: Anthropic::Internal::Type::Converter::Input}
-                )
-              ]
-            )
-          end
-          def fields; end
-
-          # @api private
-          sig do
-            params(
-              name_sym: Symbol,
-              required: T::Boolean,
-              type_info: T.any(
-                {
-                  const: T.nilable(T.any(NilClass, T::Boolean, Integer, Float, Symbol)),
-                  enum: T.nilable(T.proc.returns(Anthropic::Internal::Type::Converter::Input)),
-                  union: T.nilable(T.proc.returns(Anthropic::Internal::Type::Converter::Input)),
-                  api_name: Symbol,
-                  nil?: T::Boolean
-                },
-                T.proc.returns(Anthropic::Internal::Type::Converter::Input),
-                Anthropic::Internal::Type::Converter::Input
-              ),
-              spec: Anthropic::Internal::AnyHash
-            )
-              .void
-          end
-          private def add_field(name_sym, required:, type_info:, spec:); end
-
-          # @api private
-          sig do
-            params(
-              name_sym: Symbol,
-              type_info: T.any(
-                Anthropic::Internal::AnyHash,
-                T.proc.returns(Anthropic::Internal::Type::Converter::Input),
-                Anthropic::Internal::Type::Converter::Input
-              ),
-              spec: Anthropic::Internal::AnyHash
-            )
-              .void
-          end
-          def required(name_sym, type_info, spec = {}); end
-
-          # @api private
-          sig do
-            params(
-              name_sym: Symbol,
-              type_info: T.any(
-                Anthropic::Internal::AnyHash,
-                T.proc.returns(Anthropic::Internal::Type::Converter::Input),
-                Anthropic::Internal::Type::Converter::Input
-              ),
-              spec: Anthropic::Internal::AnyHash
-            )
-              .void
-          end
-          def optional(name_sym, type_info, spec = {}); end
-
-          # @api private
-          #
-          # `request_only` attributes not excluded from `.#coerce` when receiving responses
-          # even if well behaved servers should not send them
-          sig { params(blk: T.proc.void).void }
-          private def request_only(&blk); end
-
-          # @api private
-          #
-          # `response_only` attributes are omitted from `.#dump` when making requests
-          sig { params(blk: T.proc.void).void }
-          private def response_only(&blk); end
-
-          sig { params(other: T.anything).returns(T::Boolean) }
-          def ==(other); end
-        end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ==(other); end
-
-        class << self
-          # @api private
-          sig do
-            override
-              .params(
-                value: T.any(
-                  Anthropic::Internal::Type::BaseModel,
-                  T::Hash[T.anything, T.anything],
-                  T.anything
-                ),
-                state: Anthropic::Internal::Type::Converter::CoerceState
-              )
-              .returns(T.any(T.attached_class, T.anything))
-          end
-          def coerce(value, state:); end
-
-          # @api private
-          sig do
-            override
-              .params(value: T.any(
-                T.attached_class,
-                T.anything
-              ),
-                      state: Anthropic::Internal::Type::Converter::DumpState)
-              .returns(T.any(T::Hash[T.anything, T.anything], T.anything))
-          end
-          def dump(value, state:); end
-        end
-
-        # Returns the raw value associated with the given key, if found. Otherwise, nil is
-        # returned.
-        #
-        # It is valid to lookup keys that are not in the API spec, for example to access
-        # undocumented features. This method does not parse response data into
-        # higher-level types. Lookup by anything other than a Symbol is an ArgumentError.
-        sig { params(key: Symbol).returns(T.nilable(T.anything)) }
-        def [](key); end
-
-        # Returns a Hash of the data underlying this object. O(1)
-        #
-        # Keys are Symbols and values are the raw values from the response. The return
-        # value indicates which values were ever set on the object. i.e. there will be a
-        # key in this hash if they ever were, even if the set value was nil.
-        #
-        # This method is not recursive. The returned value is shared by the object, so it
-        # should not be mutated.
-        sig { overridable.returns(Anthropic::Internal::AnyHash) }
-        def to_h; end
-
-        # Returns a Hash of the data underlying this object. O(1)
-        #
-        # Keys are Symbols and values are the raw values from the response. The return
-        # value indicates which values were ever set on the object. i.e. there will be a
-        # key in this hash if they ever were, even if the set value was nil.
-        #
-        # This method is not recursive. The returned value is shared by the object, so it
-        # should not be mutated.
-        sig { overridable.returns(Anthropic::Internal::AnyHash) }
-        def to_hash; end
-
-        sig { params(keys: T.nilable(T::Array[Symbol])).returns(Anthropic::Internal::AnyHash) }
-        def deconstruct_keys(keys); end
-
-        sig { params(a: T.anything).returns(String) }
-        def to_json(*a); end
-
-        sig { params(a: T.anything).returns(String) }
-        def to_yaml(*a); end
-
-        # Create a new instance of a model.
-        sig { params(data: T.any(T::Hash[Symbol, T.anything], T.self_type)).returns(T.attached_class) }
-        def self.new(data = {}); end
-
-        sig { returns(String) }
-        def inspect; end
-      end
-    end
-  end
-end

data/rbi/lib/anthropic/internal/type/boolean.rbi

@@ -1,49 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      # @api private
-      #
-      # Ruby has no Boolean class; this is something for models to refer to.
-      class Boolean
-        extend Anthropic::Internal::Type::Converter
-
-        abstract!
-        final!
-
-        sig(:final) { params(other: T.anything).returns(T::Boolean) }
-        def self.===(other); end
-
-        sig(:final) { params(other: T.anything).returns(T::Boolean) }
-        def self.==(other); end
-
-        class << self
-          # @api private
-          sig(:final) do
-            override
-              .params(value: T.any(
-                T::Boolean,
-                T.anything
-              ),
-                      state: Anthropic::Internal::Type::Converter::CoerceState)
-              .returns(T.any(T::Boolean, T.anything))
-          end
-          def coerce(value, state:); end
-
-          # @api private
-          sig(:final) do
-            override
-              .params(value: T.any(
-                T::Boolean,
-                T.anything
-              ),
-                      state: Anthropic::Internal::Type::Converter::DumpState)
-              .returns(T.any(T::Boolean, T.anything))
-          end
-          def dump(value, state:); end
-        end
-      end
-    end
-  end
-end

data/rbi/lib/anthropic/internal/type/hash_of.rbi

@@ -1,82 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      # @api private
-      #
-      # Hash of items of a given type.
-      class HashOf
-        include Anthropic::Internal::Type::Converter
-
-        abstract!
-        final!
-
-        Elem = type_member(:out)
-
-        sig(:final) do
-          params(
-            type_info: T.any(
-              Anthropic::Internal::AnyHash,
-              T.proc.returns(Anthropic::Internal::Type::Converter::Input),
-              Anthropic::Internal::Type::Converter::Input
-            ),
-            spec: Anthropic::Internal::AnyHash
-          )
-            .returns(T.attached_class)
-        end
-        def self.[](type_info, spec = {}); end
-
-        sig(:final) { params(other: T.anything).returns(T::Boolean) }
-        def ===(other); end
-
-        sig(:final) { params(other: T.anything).returns(T::Boolean) }
-        def ==(other); end
-
-        # @api private
-        sig(:final) do
-          override
-            .params(
-              value: T.any(T::Hash[T.anything, T.anything], T.anything),
-              state: Anthropic::Internal::Type::Converter::CoerceState
-            )
-            .returns(T.any(Anthropic::Internal::AnyHash, T.anything))
-        end
-        def coerce(value, state:); end
-
-        # @api private
-        sig(:final) do
-          override
-            .params(
-              value: T.any(T::Hash[T.anything, T.anything], T.anything),
-              state: Anthropic::Internal::Type::Converter::DumpState
-            )
-            .returns(T.any(Anthropic::Internal::AnyHash, T.anything))
-        end
-        def dump(value, state:); end
-
-        # @api private
-        sig(:final) { returns(Elem) }
-        protected def item_type; end
-
-        # @api private
-        sig(:final) { returns(T::Boolean) }
-        protected def nilable?; end
-
-        # @api private
-        sig(:final) do
-          params(
-            type_info: T.any(
-              Anthropic::Internal::AnyHash,
-              T.proc.returns(Anthropic::Internal::Type::Converter::Input),
-              Anthropic::Internal::Type::Converter::Input
-            ),
-            spec: Anthropic::Internal::AnyHash
-          )
-            .void
-        end
-        def initialize(type_info, spec = {}); end
-      end
-    end
-  end
-end

data/rbi/lib/anthropic/internal/type/request_parameters.rbi

@@ -1,21 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      # @api private
-      module RequestParameters
-        # Options to specify HTTP behaviour for this request.
-        sig { returns(T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash)) }
-        attr_accessor :request_options
-
-        # @api private
-        module Converter
-          # @api private
-          sig { params(params: T.anything).returns([T.anything, Anthropic::Internal::AnyHash]) }
-          def dump_request(params); end
-        end
-      end
-    end
-  end
-end

data/rbi/lib/anthropic/internal/type/union.rbi

@@ -1,68 +0,0 @@
-# typed: strong
-
-module Anthropic
-  module Internal
-    module Type
-      # @api private
-      module Union
-        include Anthropic::Internal::Type::Converter
-
-        # @api private
-        #
-        # All of the specified variant info for this union.
-        sig do
-          returns(T::Array[[T.nilable(Symbol), T.proc.returns(Anthropic::Internal::Type::Converter::Input)]])
-        end
-        private def known_variants; end
-
-        # @api private
-        sig { returns(T::Array[[T.nilable(Symbol), T.anything]]) }
-        protected def derefed_variants; end
-
-        # All of the specified variants for this union.
-        sig { overridable.returns(T::Array[T.anything]) }
-        def variants; end
-
-        # @api private
-        sig { params(property: Symbol).void }
-        private def discriminator(property); end
-
-        # @api private
-        sig do
-          params(
-            key: T.any(Symbol, Anthropic::Internal::AnyHash, T.proc.returns(T.anything), T.anything),
-            spec: T.any(Anthropic::Internal::AnyHash, T.proc.returns(T.anything), T.anything)
-          )
-            .void
-        end
-        private def variant(key, spec = nil); end
-
-        # @api private
-        sig { params(value: T.anything).returns(T.nilable(T.anything)) }
-        private def resolve_variant(value); end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ===(other); end
-
-        sig { params(other: T.anything).returns(T::Boolean) }
-        def ==(other); end
-
-        # @api private
-        sig do
-          override
-            .params(value: T.anything, state: Anthropic::Internal::Type::Converter::CoerceState)
-            .returns(T.anything)
-        end
-        def coerce(value, state:); end
-
-        # @api private
-        sig do
-          override
-            .params(value: T.anything, state: Anthropic::Internal::Type::Converter::DumpState)
-            .returns(T.anything)
-        end
-        def dump(value, state:); end
-      end
-    end
-  end
-end