ruby-anthropic 0.4.2

data/lib/anthropic/http.rb

@@ -0,0 +1,200 @@
+require "event_stream_parser"
+
+require_relative "http_headers"
+
+# rubocop:disable Metrics/ModuleLength
+module Anthropic
+  module HTTP
+    include HTTPHeaders
+
+    def get(path:, parameters: nil)
+      response = conn.get(uri(path: path), parameters) do |req|
+        req.headers = headers
+      end
+      response&.body
+    end
+
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/AbcSize
+    def json_post(path:, parameters: {})
+      str_resp = {}
+      response = conn.post(uri(path: path)) do |req|
+        if parameters.respond_to?(:key?) && parameters[:stream].is_a?(Proc)
+          req.options.on_data = to_json_stream(user_proc: parameters[:stream], response: str_resp,
+                                               preprocess: parameters[:preprocess_stream])
+          parameters[:stream] = true # Necessary to tell Anthropic to stream.
+          parameters.delete(:preprocess_stream)
+        end
+
+        req.headers = headers
+        req.body = parameters.to_json
+      end
+
+      str_resp.empty? ? response.body : str_resp
+    end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
+
+    # Unused - leave in until v1 since someone might be using it.
+    def multipart_post(path:, parameters: nil)
+      to_json(conn(multipart: true).post(uri(path: path)) do |req|
+        req.headers = headers.merge({ "Content-Type" => "multipart/form-data" })
+        req.body = multipart_parameters(parameters)
+      end&.body)
+    end
+
+    # Unused - leave in until v1 since someone might be using it.
+    def delete(path:)
+      to_json(conn.delete(uri(path: path)) do |req|
+        req.headers = headers
+      end&.body)
+    end
+
+    private
+
+    # Used only in unused methods - leave in until v1 since someone might be using it.
+    def to_json(string)
+      return unless string
+
+      JSON.parse(string)
+    rescue JSON::ParserError
+      # Convert a multiline string of JSON objects to a JSON array.
+      JSON.parse(string.gsub("}\n{", "},{").prepend("[").concat("]"))
+    end
+
+    # Given a proc, returns an outer proc that can be used to iterate over a JSON stream of chunks.
+    # For each chunk, the inner user_proc is called giving it the JSON object. The JSON object could
+    # be a data object or an error object as described in the Anthropic API documentation.
+    #
+    # @param user_proc [Proc] The inner proc to call for each JSON object in the chunk.
+    # @return [Proc] An outer proc that iterates over a raw stream, converting it to JSON.
+    # rubocop:disable Metrics/MethodLength
+    def to_json_stream(user_proc:, response:, preprocess: nil)
+      parser = EventStreamParser::Parser.new
+      preprocess_stack = ""
+
+      proc do |chunk, _bytes, env|
+        # Versions of Faraday < 2.5.0 do not include an `env` argument,
+        # so we have to assume they are successful
+        handle_faraday_error(chunk, env) if env
+
+        parser.feed(chunk) do |type, data|
+          parsed_data = JSON.parse(data)
+
+          _handle_message_type(type, parsed_data, response) do |delta|
+            preprocess(preprocess, preprocess_stack, delta, user_proc) unless preprocess.nil?
+          end
+
+          user_proc.call(parsed_data) if preprocess.nil?
+        end
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # rubocop:disable Metrics/MethodLength
+    def _handle_message_type(type, parsed_data, response, &block)
+      case type
+      when "message_start"
+        response.merge!(parsed_data["message"])
+        response["content"] = [{ "type" => "text", "text" => "" }]
+      when "message_delta"
+        response["usage"].merge!(parsed_data["usage"])
+        response.merge!(parsed_data["delta"])
+      when "content_block_delta"
+        delta = parsed_data["delta"]["text"]
+        response["content"][0]["text"].concat(delta) if delta
+        block.yield delta
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Decides whether to preprocess JSON or text and calls the appropriate method.
+    def preprocess(directive, stack, delta, user_proc)
+      stack.concat(delta) if delta # Alters the stack.
+      case directive
+      when :json
+        preprocess_json(stack, delta, user_proc)
+      when :text
+        preprocess_text(stack, delta, user_proc)
+      else
+        raise Anthropic::Error,
+              "Invalid preprocess directive (valid: :text, :json): #{directive.inspect}"
+      end
+    end
+
+    # Just sends the incremental response (aka stack) and delta up to the user
+    def preprocess_text(stack, delta, user_proc)
+      user_proc.call(stack, delta)
+    end
+
+    # If the stack contains a +}+, uses a regexp to try to find a complete JSON object.
+    # If it finds one, it calls the user_proc with the JSON object. If it fails, catches and logs
+    # an exception but does not currently raise it, which means that if there is just one malformed
+    # JSON object (which does happen, albeit rarely), it will continue and process the other ones.
+    #
+    # TODO: Make the exception processing parametrisable (set logger? exit on error?)
+    def preprocess_json(stack, _delta, user_proc)
+      if stack.strip.include?("}")
+        matches = stack.match(/\{(?:[^{}]|\g<0>)*\}/)
+        user_proc.call(JSON.parse(matches[0]))
+        stack.clear
+      end
+    rescue StandardError => e
+      log(e)
+    ensure
+      stack.clear if stack.strip.include?("}")
+    end
+
+    def log(error)
+      logger = Logger.new($stdout)
+      logger.formatter = proc do |_severity, _datetime, _progname, msg|
+        "\033[31mAnthropic Error (spotted in anthropic #{VERSION}): #{msg}\n\033[0m"
+      end
+      logger.error(error)
+    end
+
+    def handle_faraday_error(chunk, env)
+      return unless env&.status != 200
+
+      raise_error = Faraday::Response::RaiseError.new
+      raise_error.on_complete(env.merge(body: try_parse_json(chunk)))
+    end
+
+    def conn(multipart: false)
+      connection = Faraday.new do |f|
+        f.options[:timeout] = @request_timeout
+        f.request(:multipart) if multipart
+        f.use MiddlewareErrors if @log_errors
+        f.response :raise_error
+        f.response :json
+      end
+
+      @faraday_middleware&.call(connection)
+
+      connection
+    end
+
+    def uri(path:)
+      Anthropic.configuration.uri_base + Anthropic.configuration.api_version + path
+    end
+
+    # Unused except by unused method
+    def multipart_parameters(parameters)
+      parameters&.transform_values do |value|
+        next value unless value.is_a?(File)
+
+        # Doesn't seem like Anthropic needs mime_type yet, so not worth
+        # the library to figure this out. Hence the empty string
+        # as the second argument.
+        Faraday::UploadIO.new(value, "", value.path)
+      end
+    end
+
+    def try_parse_json(maybe_json)
+      JSON.parse(maybe_json)
+    rescue JSON::ParserError
+      maybe_json
+    end
+  end
+end
+# rubocop:enable Metrics/ModuleLength

data/lib/anthropic/http_headers.rb

@@ -0,0 +1,38 @@
+module Anthropic
+  module HTTPHeaders
+    def add_headers(headers)
+      @extra_headers = extra_headers.merge(headers.transform_keys(&:to_s))
+    end
+
+    private
+
+    def headers
+      # TODO: Implement Amazon Bedrock headers
+      # if azure?
+      #   azure_headers
+      # else
+      #   anthropic_headers
+      # end.merge(extra_headers)
+      anthropic_headers.merge(extra_headers)
+    end
+
+    def anthropic_headers
+      {
+        "x-api-key" => @access_token,
+        "anthropic-version" => @anthropic_version,
+        "Content-Type" => "application/json"
+      }
+    end
+
+    # def azure_headers
+    #   {
+    #     "Content-Type" => "application/json",
+    #     "api-key" => @access_token
+    #   }
+    # end
+
+    def extra_headers
+      @extra_headers ||= {}
+    end
+  end
+end

data/lib/anthropic/messages/batches.rb

@@ -0,0 +1,112 @@
+module Anthropic
+  module Messages
+    class Batches
+      BETA_VERSION = "message-batches-2024-09-24".freeze
+
+      def initialize(client)
+        @client = client.beta(BETA_VERSION)
+      end
+
+      # Anthropic API Parameters as of 2024-10-09:
+      # @see https://docs.anthropic.com/en/api/creating-message-batches
+      #
+      # @param [Array] :parameters - List of requests for prompt completion.
+      # Each is an individual request to create a Message.
+      # Parameters are an array of hashes, each with the following keys:
+      # - :custom_id (required): Developer-provided ID created for each request in a Message Batch.
+      # Useful for matching results to requests, as results may be given out of request order.
+      # Must be unique for each request within the Message Batch.
+      # - :params (required): Messages API creation parameters for the individual request.
+      # See the Messages API reference for full documentation on available parameters.
+      #
+      # @returns [Hash] the response from the API (after the streaming is done, if streaming)
+      # @example:
+      #
+      # > messages.batches.create(parameters: [message1, message2])
+      # {
+      #   "id"=>"msgbatch_01668jySCZeCpMLsxFcroNnN",
+      #   "type"=>"message_batch",
+      #   "processing_status"=>"in_progress",
+      #   "request_counts"=>{
+      #     "processing"=>2,
+      #     "succeeded"=>0,
+      #     "errored"=>0,
+      #     "canceled"=>0,
+      #     "expired"=>0
+      #   },
+      #   "ended_at"=>nil,
+      #   "created_at"=>"2024-10-09T20:18:11.480471+00:00",
+      #   "expires_at"=>"2024-10-10T20:18:11.480471+00:00",
+      #   "cancel_initiated_at"=>nil,
+      #   "results_url"=>nil
+      # }
+      def create(parameters: {})
+        @client.json_post(
+          path: "/messages/batches",
+          parameters: parameters
+        )
+      end
+
+      # Anthropic API Parameters as of 2024-10-09:
+      # @see https://docs.anthropic.com/en/api/creating-message-batches
+      #
+      # @param [String] :id - ID of the Message Batch.
+      #
+      # @returns [Hash] the same response shape as #create method.
+      def get(id:)
+        @client.get(path: "/messages/batches/#{id}")
+      end
+
+      # Anthropic API Parameters as of 2024-10-09:
+      # @see https://docs.anthropic.com/en/api/creating-message-batches
+      #
+      # @param [String] :id - ID of the Message Batch.
+      #
+      # Returns the results of a Message Batch as a .jsonl file.
+      # Each line in the file is a JSON object containing the result of a
+      # single request in the Message Batch.
+      # Results are not guaranteed to be in the same order as requests.
+      # Use the custom_id field to match results to requests.
+      def results(id:)
+        @client.get(path: "/messages/batches/#{id}/results")
+      end
+
+      # Anthropic API Parameters as of 2024-10-09:
+      # @see https://docs.anthropic.com/en/api/listing-message-batches
+      #
+      # List all Message Batches within a Workspace. Most recently created batches returned first.
+      # @param [String] :before_id - ID of the object to use as a cursor for pagination.
+      # When provided, returns the page of results immediately before this object.
+      #
+      # @param [String] :after_id - ID of the object to use as a cursor for pagination.
+      # When provided, returns the page of results immediately after this object.
+      #
+      # @param [Integer] :limit - Number of items to return per page.
+      # Defaults to 20. Ranges from 1 to 100.
+      #
+      # @returns [Hash] the response from the API
+      def list(parameters: {})
+        @client.get(path: "/messages/batches", parameters: parameters)
+      end
+
+      # Anthropic API Parameters as of 2024-10-09:
+      # @see https://docs.anthropic.com/en/api/creating-message-batches
+      #
+      # @param [String] :id - ID of the Message Batch.
+      #
+      # @returns [Hash] the response from the API
+      #
+      # Cancel a Message Batch.
+      # Batches may be canceled any time before processing ends. Once cancellation is initiated,
+      # the batch enters a canceling state, at which time the system may complete any in-progress,
+      # non-interruptible requests before finalizing cancellation.
+      #
+      # The number of canceled requests is specified in request_counts.
+      # To determine which requests were canceled, check the individual results within the batch.
+      # Note that cancellation may not cancel any requests if they were non-interruptible.
+      def cancel(id:)
+        @client.json_post(path: "/messages/batches/#{id}/cancel")
+      end
+    end
+  end
+end

data/lib/anthropic/messages/client.rb

@@ -0,0 +1,13 @@
+module Anthropic
+  module Messages
+    class Client
+      def initialize(client)
+        @client = client
+      end
+
+      def batches
+        @batches ||= Batches.new(@client)
+      end
+    end
+  end
+end

data/lib/anthropic/version.rb

@@ -0,0 +1,3 @@
+module Anthropic
+  VERSION = "0.4.2".freeze
+end

data/lib/anthropic.rb

@@ -0,0 +1,72 @@
+require "faraday"
+require "faraday/multipart"
+
+require_relative "anthropic/http"
+require_relative "anthropic/client"
+require_relative "anthropic/version"
+
+module Anthropic
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+
+  class MiddlewareErrors < Faraday::Middleware
+    def call(env)
+      @app.call(env)
+    rescue Faraday::Error => e
+      raise e unless e.response.is_a?(Hash)
+
+      logger = Logger.new($stdout)
+      logger.formatter = proc do |_severity, _datetime, _progname, msg|
+        "\033[31mAnthropic HTTP Error (spotted in anthropic #{VERSION}): #{msg}\n\033[0m"
+      end
+      logger.error(e.response[:body])
+
+      raise e
+    end
+  end
+
+  class Configuration
+    attr_writer :access_token
+    attr_accessor :anthropic_version,
+                  :api_version,
+                  :extra_headers,
+                  :log_errors,
+                  :request_timeout,
+                  :uri_base
+
+    DEFAULT_API_VERSION = "v1".freeze
+    DEFAULT_ANTHROPIC_VERSION = "2023-06-01".freeze
+    DEFAULT_LOG_ERRORS = false
+    DEFAULT_URI_BASE = "https://api.anthropic.com/".freeze
+    DEFAULT_REQUEST_TIMEOUT = 120
+
+    def initialize
+      @access_token = nil
+      @api_version = DEFAULT_API_VERSION
+      @anthropic_version = DEFAULT_ANTHROPIC_VERSION
+      @log_errors = DEFAULT_LOG_ERRORS
+      @uri_base = DEFAULT_URI_BASE
+      @request_timeout = DEFAULT_REQUEST_TIMEOUT
+      @extra_headers = {}
+    end
+
+    def access_token
+      return @access_token if @access_token
+
+      error_text = "Anthropic access token missing! See https://github.com/alexrudall/ruby-anthropic#usage"
+      raise ConfigurationError, error_text
+    end
+  end
+
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= Anthropic::Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end

data/lib/ruby/anthropic.rb

@@ -0,0 +1,2 @@
+require_relative "../anthropic"
+require_relative "../anthropic/compatibility"

data/pull_request_template.md

@@ -0,0 +1,5 @@
+## All Submissions:
+
+* [ ] Have you followed the guidelines in our [Contributing document](../blob/main/CONTRIBUTING.md)?
+* [ ] Have you checked to ensure there aren't other open [Pull Requests](../pulls) for the same update/change?
+* [ ] Have you added an explanation of what your changes do and why you'd like us to include them?

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: ruby-anthropic
+version: !ruby/object:Gem::Version
+  version: 0.4.2
+platform: ruby
+authors:
+- Alex
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-04-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: event_stream_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: faraday-multipart
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+description:
+email:
+- alexrudall@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".circleci/config.yml"
+- ".github/ISSUE_TEMPLATE/bug_report.md"
+- ".github/ISSUE_TEMPLATE/feature_request.md"
+- ".github/dependabot.yml"
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- CONTRIBUTING.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- anthropic.gemspec
+- bin/console
+- bin/setup
+- lib/anthropic.rb
+- lib/anthropic/client.rb
+- lib/anthropic/compatibility.rb
+- lib/anthropic/http.rb
+- lib/anthropic/http_headers.rb
+- lib/anthropic/messages/batches.rb
+- lib/anthropic/messages/client.rb
+- lib/anthropic/version.rb
+- lib/ruby/anthropic.rb
+- pull_request_template.md
+homepage: https://github.com/alexrudall/ruby-anthropic
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/alexrudall/ruby-anthropic
+  source_code_uri: https://github.com/alexrudall/ruby-anthropic
+  changelog_uri: https://github.com/alexrudall/ruby-anthropic/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.11
+signing_key:
+specification_version: 4
+summary: "Anthropic API + Ruby! \U0001F916\U0001F30C"
+test_files: []