anthropic 0.4.0 → 1.0.0

data/lib/anthropic/helpers/bedrock/client.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module Bedrock
+      class Client < Anthropic::Client
+        DEFAULT_VERSION = "bedrock-2023-05-31"
+
+        # @return [Anthropic::Resources::Messages]
+        attr_reader :messages
+
+        # @return [Anthropic::Resources::Completions]
+        attr_reader :completions
+
+        # @return [Anthropic::Resources::Beta]
+        attr_reader :beta
+
+        # @return [String]
+        attr_reader :aws_region
+
+        # @return [Aws::Credentials]
+        attr_reader :aws_credentials
+
+        # Creates and returns a new client for interacting with the AWS Bedrock API for Anthropic models.
+        #
+        # AWS credentials are resolved according to the AWS SDK's default resolution order, described at
+        #   https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/setup-config.html#credchain or https://github.com/aws/aws-sdk-ruby?tab=readme-ov-file#configuration
+        #
+        # @param aws_region [String, nil] Enforce the AWS Region to use. If unset, the region is set according to the
+        #   AWS SDK's default resolution order, described at https://github.com/aws/aws-sdk-ruby?tab=readme-ov-file#configuration
+        #
+        # @param aws_access_key [String, nil]  Optional AWS access key to use for authentication. Overrides profile and credential provider chain
+        #
+        # @param aws_secret_key [String, nil] Optional AWS secret access key to use for authentication. Overrides profile and credential provider chain
+        #
+        # @param aws_session_token [String, nil] Optional AWS session token to use for authentication. Overrides profile and credential provider chain
+        #
+        # @param aws_profile [String, nil] Optional AWS profile to use for authentication. Overrides the credential provider chain
+        #
+        # @param base_url [String, nil] Override the default base URL for the API, e.g., `"https://api.example.com/v2/"`
+        #
+        # @param max_retries [Integer] The maximum number of times to retry a request if it fails
+        #
+        # @param timeout [Float] The number of seconds to wait for a response before timing out
+        #
+        # @param initial_retry_delay [Float] The number of seconds to wait before retrying a request
+        #
+        # @param max_retry_delay [Float] The maximum number of seconds to wait before retrying a request
+        #
+        def initialize(
+          aws_region: nil,
+          base_url: nil,
+          max_retries: DEFAULT_MAX_RETRIES,
+          timeout: DEFAULT_TIMEOUT_IN_SECONDS,
+          initial_retry_delay: DEFAULT_INITIAL_RETRY_DELAY,
+          max_retry_delay: DEFAULT_MAX_RETRY_DELAY,
+          aws_access_key: nil,
+          aws_secret_key: nil,
+          aws_session_token: nil,
+          aws_profile: nil
+        )
+          begin
+            require("aws-sdk-bedrockruntime")
+          rescue LoadError
+            raise <<~MSG
+
+              In order to access Anthropic models on Bedrock you must require the `aws-sdk-bedrockruntime` gem.
+              You can install it by adding the following to your Gemfile:
+
+                  gem "aws-sdk-bedrockruntime"
+
+              and then running `bundle install`.
+
+              Alternatively, if you are not using Bundler, simply run:
+
+                  gem install aws-sdk-bedrockruntime
+            MSG
+          end
+
+          @aws_region, @aws_credentials = resolve_region_and_credentials(
+            aws_region: aws_region,
+            aws_secret_key: aws_secret_key,
+            aws_access_key: aws_access_key,
+            aws_session_token: aws_session_token,
+            aws_profile: aws_profile
+          )
+
+          @signer = Aws::Sigv4::Signer.new(
+            service: "bedrock",
+            region: @aws_region,
+            credentials: @aws_credentials
+          )
+
+          base_url ||= ENV.fetch(
+            "ANTHROPIC_BEDROCK_BASE_URL",
+            "https://bedrock-runtime.#{@aws_region}.amazonaws.com"
+          )
+
+          super(
+            base_url: base_url,
+            timeout: timeout,
+            max_retries: max_retries,
+            initial_retry_delay: initial_retry_delay,
+            max_retry_delay: max_retry_delay,
+          )
+
+          @messages = Anthropic::Resources::Messages.new(client: self)
+          @completions = Anthropic::Resources::Completions.new(client: self)
+          @beta = Anthropic::Resources::Beta.new(client: self)
+        end
+
+        # @api private
+        #
+        # @param req [Hash{Symbol=>Object}] .
+        #
+        #   @option req [Symbol] :method
+        #
+        #   @option req [String, Array<String>] :path
+        #
+        #   @option req [Hash{String=>Array<String>, String, nil}, nil] :query
+        #
+        #   @option req [Hash{String=>String, Integer, Array<String, Integer, nil>, nil}, nil] :headers
+        #
+        #   @option req [Object, nil] :body
+        #
+        #   @option req [Symbol, Integer, Array<Symbol, Integer>, Proc, nil] :unwrap
+        #
+        #   @option req [Class<Anthropic::Internal::Type::BasePage>, nil] :page
+        #
+        #   @option req [Class<Anthropic::Internal::Type::BaseStream>, nil] :stream
+        #
+        #   @option req [Anthropic::Internal::Type::Converter, Class, nil] :model
+        #
+        # @param opts [Hash{Symbol=>Object}] .
+        #
+        #   @option opts [String, nil] :idempotency_key
+        #
+        #   @option opts [Hash{String=>Array<String>, String, nil}, nil] :extra_query
+        #
+        #   @option opts [Hash{String=>String, nil}, nil] :extra_headers
+        #
+        #   @option opts [Object, nil] :extra_body
+        #
+        #   @option opts [Integer, nil] :max_retries
+        #
+        #   @option opts [Float, nil] :timeout
+        #
+        # @return [Hash{Symbol=>Object}]
+        private def build_request(req, opts)
+          fit_req_to_bedrock_specs!(req)
+
+          request_input = super
+
+          signed_request = @signer.sign_request(
+            http_method: request_input[:method],
+            url: request_input[:url],
+            headers: request_input[:headers],
+            body: request_input[:body]
+          )
+
+          request_input[:headers].merge!(signed_request.headers)
+
+          request_input
+        end
+
+        # @param aws_region [String, nil]
+        #
+        # @param aws_secret_key [String, nil]
+        #
+        # @param aws_access_key [String, nil]
+        #
+        # @param aws_session_token [String, nil]
+        #
+        # @param aws_profile [String, nil]
+        #
+        # @return [Array<String, Aws::Credentials>]
+        #
+        private def resolve_region_and_credentials(
+          aws_region:,
+          aws_secret_key:,
+          aws_access_key:,
+          aws_session_token:,
+          aws_profile:
+        )
+          client_options = {
+            access_key_id: aws_access_key,
+            secret_access_key: aws_secret_key,
+            session_token: aws_session_token,
+            profile: aws_profile
+          }
+          (client_options[:region] = aws_region) unless aws_region.nil?
+
+          bedrock_client = Aws::BedrockRuntime::Client.new(client_options)
+          [bedrock_client.config.region, bedrock_client.config.credentials.credentials]
+        end
+
+        # @private
+        #
+        # Overrides request components for Bedrock-specific request-shape requirements.
+        #
+        # @param request_components [Hash{Symbol=>Object}] .
+        #
+        #   @option request_components [Symbol] :method
+        #
+        #   @option request_components [String, Array<String>] :path
+        #
+        #   @option request_components [Hash{String=>Array<String>, String, nil}, nil] :query
+        #
+        #   @option request_components [Hash{String=>String, nil}, nil] :headers
+        #
+        #   @option request_components [Object, nil] :body
+        #
+        #   @option request_components [Symbol, nil] :unwrap
+        #
+        #   @option request_components [Class, nil] :page
+        #
+        #   @option request_components [Anthropic::Converter, Class, nil] :model
+        #
+        # @return [Hash{Symbol=>Object}]
+        #
+        private def fit_req_to_bedrock_specs!(request_components)
+          if (body = request_components[:body]).is_a?(Hash)
+            body[:anthropic_version] ||= DEFAULT_VERSION
+            body.transform_keys!("anthropic-beta": :anthropic_beta)
+          end
+
+          case request_components[:path]
+          in %r{^v1/messages/batches}
+            message = "The Batch API is not supported in Bedrock yet"
+            raise NotImplementedError.new(message)
+          in %r{v1/messages/count_tokens}
+            message = "Token counting is not supported in Bedrock yet"
+            raise NotImplementedError.new(message)
+          in %r{v1/models\?beta=true}
+            # rubocop:disable Layout/LineLength
+            message = "Please instead use https://docs.anthropic.com/en/api/claude-on-amazon-bedrock#list-available-models to list available models on Bedrock."
+            # rubocop:enable Layout/LineLength
+            raise NotImplementedError.new(message)
+          else
+          end
+
+          if %w[
+            v1/complete
+            v1/messages
+            v1/messages?beta=true
+          ].include?(request_components[:path]) && request_components[:method] == :post && body.is_a?(Hash)
+            model = body.delete(:model)
+            model = URI.encode_www_form_component(model.to_s)
+            stream = body.delete(:stream) || false
+            request_components[:path] =
+              stream ? "model/#{model}/invoke-with-response-stream" : "model/#{model}/invoke"
+          end
+
+          request_components
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/vertex/client.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module Vertex
+      class Client < Anthropic::Client
+        DEFAULT_VERSION = "vertex-2023-10-16"
+
+        # @return [String]
+        attr_reader :region
+
+        # @return [String]
+        attr_reader :project_id
+
+        # @return [Anthropic::Resources::Messages]
+        attr_reader :messages
+
+        # @return [Anthropic::Resources::Beta]
+        attr_reader :beta
+
+        # Creates and returns a new client for interacting with the GCP Vertex API for Anthropic models.
+        #
+        # GCP credentials are resolved according to Application Default Credentials, described at
+        #   https://cloud.google.com/docs/authentication/provide-credentials-adc
+        #
+        # @param region [String, nil] Enforce the GCP Region to use. If unset, the region may be set with the CLOUD_ML_REGION environment variable.
+        #
+        # @param project_id [String, nil] Enforce the GCP Project ID to use. If unset, the project_id may be set with the ANTHROPIC_VERTEX_PROJECT_ID environment variable.
+        #
+        # @param base_url [String, nil] Override the default base URL for the API, e.g., `"https://api.example.com/v2/"`
+        #
+        # @param max_retries [Integer] The maximum number of times to retry a request if it fails
+        #
+        # @param timeout [Float] The number of seconds to wait for a response before timing out
+        #
+        # @param initial_retry_delay [Float] The number of seconds to wait before retrying a request
+        #
+        # @param max_retry_delay [Float] The maximum number of seconds to wait before retrying a request
+        #
+        def initialize(
+          region: ENV["CLOUD_ML_REGION"],
+          project_id: ENV["ANTHROPIC_VERTEX_PROJECT_ID"],
+          base_url: nil,
+          max_retries: DEFAULT_MAX_RETRIES,
+          timeout: DEFAULT_TIMEOUT_IN_SECONDS,
+          initial_retry_delay: DEFAULT_INITIAL_RETRY_DELAY,
+          max_retry_delay: DEFAULT_MAX_RETRY_DELAY
+        )
+          begin
+            require("googleauth")
+          rescue LoadError
+            raise <<~MSG
+
+              In order to access Anthropic models on Vertex you must require the `googleauth` gem.
+              You can install it by adding the following to your Gemfile:
+
+                  gem "googleauth"
+
+              and then running `bundle install`.
+
+              Alternatively, if you are not using Bundler, simply run:
+
+                  gem install googleauth
+            MSG
+          end
+
+          if region.to_s.empty?
+            # rubocop:disable Layout/LineLength
+            message = "No region was given. The client should be instantiated with the `region` argument or the `CLOUD_ML_REGION` environment variable should be set."
+            # rubocop:enable Layout/LineLength
+            raise ArgumentError.new(message)
+          end
+          @region = region
+
+          if project_id.to_s.empty?
+            # rubocop:disable Layout/LineLength
+            message = "No project_id was given and it could not be resolved from credentials. The client should be instantiated with the `project_id` argument or the `ANTHROPIC_VERTEX_PROJECT_ID` environment variable should be set."
+            # rubocop:enable Layout/LineLength
+            raise ArgumentError.new(message)
+          end
+          @project_id = project_id
+
+          base_url ||= ENV.fetch("ANTHROPIC_VERTEX_BASE_URL", "https://#{@region}-aiplatform.googleapis.com/v1")
+
+          super(
+            base_url: base_url,
+            timeout: timeout,
+            max_retries: max_retries,
+            initial_retry_delay: initial_retry_delay,
+            max_retry_delay: max_retry_delay,
+          )
+
+          @messages = Anthropic::Resources::Messages.new(client: self)
+          @beta = Anthropic::Resources::Beta.new(client: self)
+        end
+
+        # @api private
+        #
+        # @param req [Hash{Symbol=>Object}] .
+        #
+        #   @option req [Symbol] :method
+        #
+        #   @option req [String, Array<String>] :path
+        #
+        #   @option req [Hash{String=>Array<String>, String, nil}, nil] :query
+        #
+        #   @option req [Hash{String=>String, Integer, Array<String, Integer, nil>, nil}, nil] :headers
+        #
+        #   @option req [Object, nil] :body
+        #
+        #   @option req [Symbol, Integer, Array<Symbol, Integer>, Proc, nil] :unwrap
+        #
+        #   @option req [Class<Anthropic::Internal::Type::BasePage>, nil] :page
+        #
+        #   @option req [Class<Anthropic::Internal::Type::BaseStream>, nil] :stream
+        #
+        #   @option req [Anthropic::Internal::Type::Converter, Class, nil] :model
+        #
+        # @param opts [Hash{Symbol=>Object}] .
+        #
+        #   @option opts [String, nil] :idempotency_key
+        #
+        #   @option opts [Hash{String=>Array<String>, String, nil}, nil] :extra_query
+        #
+        #   @option opts [Hash{String=>String, nil}, nil] :extra_headers
+        #
+        #   @option opts [Object, nil] :extra_body
+        #
+        #   @option opts [Integer, nil] :max_retries
+        #
+        #   @option opts [Float, nil] :timeout
+        #
+        # @return [Hash{Symbol=>Object}]
+        private def build_request(req, opts)
+          fit_req_to_vertex_specs!(req)
+
+          request_input = super
+
+          headers = request_input.fetch(:headers)
+
+          unless headers.key?("authorization")
+            authorization = Google::Auth.get_application_default(["https://www.googleapis.com/auth/cloud-platform"])
+            request_input.store(:headers, authorization.apply(headers))
+          end
+
+          request_input
+        end
+
+        # @private
+        #
+        # Overrides request components for Vertex-specific request-shape requirements.
+        #
+        # @param request_components [Hash{Symbol=>Object}] .
+        #
+        #   @option request_components [Symbol] :method
+        #
+        #   @option request_components [String, Array<String>] :path
+        #
+        #   @option request_components [Hash{String=>Array<String>, String, nil}, nil] :query
+        #
+        #   @option request_components [Hash{String=>String, nil}, nil] :headers
+        #
+        #   @option request_components [Object, nil] :body
+        #
+        #   @option request_components [Symbol, nil] :unwrap
+        #
+        #   @option request_components [Class, nil] :page
+        #
+        #   @option request_components [Anthropic::Converter, Class, nil] :model
+        #
+        # @return [Hash{Symbol=>Object}]
+        private def fit_req_to_vertex_specs!(request_components)
+          if (body = request_components[:body]).is_a?(Hash)
+            body[:anthropic_version] ||= DEFAULT_VERSION
+
+            if (anthropic_beta = body.delete(:"anthropic-beta"))
+              request_components[:headers] ||= {}
+              request_components[:headers]["anthropic-beta"] = anthropic_beta.join(",")
+            end
+          end
+
+          if %w[
+            v1/messages
+            v1/messages?beta=true
+          ].include?(request_components[:path]) && request_components[:method] == :post
+
+            unless body.is_a?(Hash)
+              raise Anthropic::Error, "Expected json data to be a hash for post /v1/messages"
+            end
+
+            model = body.delete(:model)
+            specifier = body[:stream] ? "streamRawPredict" : "rawPredict"
+
+            request_components[:path] =
+              "projects/#{@project_id}/locations/#{region}/publishers/anthropic/models/#{model}:#{specifier}"
+
+          end
+
+          if %w[
+            v1/messages/count_tokens
+            v1/messages/count_tokens?beta=true
+          ].include?(request_components[:path]) &&
+             request_components[:method] == :post
+            request_components[:path] =
+              "projects/#{@project_id}/locations/#{region}/publishers/anthropic/models/count-tokens:rawPredict"
+
+          end
+
+          if request_components[:path].start_with?("v1/messages/batches/")
+            raise AnthropicError("The Batch API is not supported in the Vertex client yet")
+          end
+
+          request_components
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/internal/jsonl_stream.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Internal
+    # @generic Elem
+    #
+    # @example
+    #   stream.each do |batch|
+    #     puts(batch)
+    #   end
+    class JsonLStream
+      include Anthropic::Internal::Type::BaseStream
+
+      # @api private
+      #
+      # @return [Enumerable<generic<Elem>>]
+      private def iterator
+        @iterator ||= Anthropic::Internal::Util.chain_fused(@stream) do |y|
+          @stream.each do
+            y << Anthropic::Internal::Type::Converter.coerce(@model, _1)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/internal/page.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Internal
+    # @generic Elem
+    #
+    # @example
+    #   if page.has_next?
+    #     page = page.next_page
+    #   end
+    #
+    # @example
+    #   page.auto_paging_each do |batch|
+    #     puts(batch)
+    #   end
+    class Page
+      include Anthropic::Internal::Type::BasePage
+
+      # @return [Array<generic<Elem>>, nil]
+      attr_accessor :data
+
+      # @return [Boolean]
+      attr_accessor :has_more
+
+      # @return [String, nil]
+      attr_accessor :first_id
+
+      # @return [String, nil]
+      attr_accessor :last_id
+
+      # @return [Boolean]
+      def next_page?
+        has_more
+      end
+
+      # @raise [Anthropic::HTTP::Error]
+      # @return [self]
+      def next_page
+        unless next_page?
+          message = "No more pages available. Please check #next_page? before calling ##{__method__}"
+          raise RuntimeError.new(message)
+        end
+
+        req = Anthropic::Internal::Util.deep_merge(
+          @req,
+          {query: first_id.nil? ? {after_id: last_id} : {before_id: first_id}}
+        )
+        @client.request(req)
+      end
+
+      # @param blk [Proc]
+      #
+      # @yieldparam [generic<Elem>]
+      def auto_paging_each(&blk)
+        unless block_given?
+          raise ArgumentError.new("A block must be given to ##{__method__}")
+        end
+
+        page = self
+        loop do
+          page.data&.each(&blk)
+
+          break unless page.next_page?
+          page = page.next_page
+        end
+      end
+
+      # @api private
+      #
+      # @param client [Anthropic::Internal::Transport::BaseClient]
+      # @param req [Hash{Symbol=>Object}]
+      # @param headers [Hash{String=>String}, Net::HTTPHeader]
+      # @param page_data [Hash{Symbol=>Object}]
+      def initialize(client:, req:, headers:, page_data:)
+        super
+
+        case page_data
+        in {data: Array => data}
+          @data = data.map { Anthropic::Internal::Type::Converter.coerce(@model, _1) }
+        else
+        end
+        @has_more = page_data[:has_more]
+        @first_id = page_data[:first_id]
+        @last_id = page_data[:last_id]
+      end
+
+      # @api private
+      #
+      # @return [String]
+      def inspect
+        # rubocop:disable Layout/LineLength
+        model = Anthropic::Internal::Type::Converter.inspect(@model, depth: 1)
+
+        "#<#{self.class}[#{model}]:0x#{object_id.to_s(16)} has_more=#{has_more.inspect} first_id=#{first_id.inspect} last_id=#{last_id.inspect}>"
+        # rubocop:enable Layout/LineLength
+      end
+    end
+  end
+end

data/lib/anthropic/internal/stream.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Internal
+    # @generic Elem
+    #
+    # @example
+    #   stream.each do |event|
+    #     puts(event)
+    #   end
+    class Stream
+      include Anthropic::Internal::Type::BaseStream
+
+      # @api private
+      #
+      # @return [Enumerable<generic<Elem>>]
+      private def iterator
+        # rubocop:disable Metrics/BlockLength
+        # rubocop:disable Layout/LineLength
+        # rubocop:disable Lint/DuplicateBranch
+        @iterator ||= Anthropic::Internal::Util.chain_fused(@stream) do |y|
+          @stream.each do |msg|
+            case msg
+            in {event: "completion", data: String => data}
+              decoded = JSON.parse(data, symbolize_names: true)
+              y << Anthropic::Internal::Type::Converter.coerce(@model, decoded)
+            in {
+              event: "message_start" | "message_delta" | "message_stop" | "content_block_start" | "content_block_delta" | "content_block_stop",
+              data: String => data
+            }
+              decoded = JSON.parse(data, symbolize_names: true)
+              y << Anthropic::Internal::Type::Converter.coerce(@model, decoded)
+            in {event: "ping"}
+              next
+            in {event: "error", data: String => data}
+              decoded = Kernel.then do
+                JSON.parse(data, symbolize_names: true)
+              rescue JSON::ParserError
+                data
+              end
+              Anthropic::Errors::APIStatusError.for(
+                url: @url,
+                status: @status,
+                body: decoded,
+                request: nil,
+                response: @response
+              )
+            else
+            end
+          end
+        end
+        # rubocop:enable Lint/DuplicateBranch
+        # rubocop:enable Layout/LineLength
+        # rubocop:enable Metrics/BlockLength
+      end
+    end
+  end
+end