anthropic 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5591b52e376e9a5915a3011d9919d188aaa441fa65f6a8d665b160c5529b0564
-  data.tar.gz: e251bf3dd61569807e722f6fe116498fd6801e07fc2333c2f2f40c03e61b5b9f
+  metadata.gz: ef2ed78af9f188f394fce182554887c8a38c68864f05796f23ccd3e57cf38d40
+  data.tar.gz: 65495af068a5f373e6d77dbc0085846c75e1a77dab2139fe0a06bbc62678e3ea
 SHA512:
-  metadata.gz: 6beac221f3595b6599e37175190a59fc20681aa679d7746f060447850aab0b4ca7362ef5ce99a458a9ce1a5f6acfc5a6491ca5bdb7147efadf14cca068576d08
-  data.tar.gz: 39189b30389c23c56956b32135587513f3ae7f2927e323262333c82392b5c24239c3a94486a68b2bd569856fe34334a19eb8a3ad7a0f0d99ef9bd5ec16283580
+  metadata.gz: e508affc831d8136633d74ca73026fb5936d52bf1ffbb82541a8ead24c5e4dec640faef5d3747986d242bde4296efc6e5ceac6688c091641da13b74a27371819
+  data.tar.gz: 4fd4fd39c63c902c1a54d71fe884329eaca8d7d5a385beb6fdf3c2e3fabeb8cbf4f67a41014d2df43eef15707ef474ee892c7f954f46ca34f33c625577038b6f

data/CHANGELOG.md

@@ -5,11 +5,17 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.0] - 2024-06-10
+
+### Added
+
+- Add chat streaming! Thank you to the inimitable [@swombat](https://github.com/swombat) for adding this vital functionality!
+
 ## [0.2.0] - 2024-04-25
 
 ### Added
 
-- Add new Messages endpoint - thanks [@deepakmahakale](https://github.com/deepakmahakale) for the PR, [@obie](https://github.com/obie) for the first pass, and many others for requesting and contributions!
+- Add new Messages endpoint - thanks [@svs](https://github.com/svs) for the PR, [@obie](https://github.com/obie) for the first pass, and many others for requesting and contributions!
 
 ## [0.1.0] - 2023-07-18
 

data/Gemfile

@@ -5,6 +5,7 @@ gemspec
 
 gem "byebug", "~> 11.1.3"
 gem "dotenv", "~> 2.8.1"
+gem "racc", "~> 1.7.3"
 gem "rake", "~> 13.0"
 gem "rspec", "~> 3.12"
 gem "rubocop", "~> 1.50.2"

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    anthropic (0.2.0)
+    anthropic (0.3.0)
+      event_stream_parser (>= 0.3.0, < 2.0.0)
       faraday (>= 1)
       faraday-multipart (>= 1)
 
@@ -16,6 +17,7 @@ GEM
       rexml
     diff-lcs (1.5.0)
     dotenv (2.8.1)
+    event_stream_parser (1.0.0)
     faraday (2.7.10)
       faraday-net_http (>= 2.0, < 3.1)
       ruby2_keywords (>= 0.0.4)
@@ -29,6 +31,7 @@ GEM
     parser (3.2.2.0)
       ast (~> 2.4.1)
     public_suffix (5.0.1)
+    racc (1.7.3)
     rainbow (3.1.1)
     rake (13.0.6)
     regexp_parser (2.8.0)
@@ -74,6 +77,7 @@ DEPENDENCIES
   anthropic!
   byebug (~> 11.1.3)
   dotenv (~> 2.8.1)
+  racc (~> 1.7.3)
   rake (~> 13.0)
   rspec (~> 3.12)
   rubocop (~> 1.50.2)

data/README.md

@@ -6,9 +6,7 @@
 
 Use the [Anthropic API](https://docs.anthropic.com/claude/reference/getting-started-with-the-api) with Ruby! 🤖🌌
 
-You can apply for access to the API [here](https://docs.anthropic.com/claude/docs/getting-access-to-claude).
-
-🚢 Need someone to ship critical Rails features for you, fast? I'm taking on a few new clients at an experimental crazy low price, check it out: [railsai.com](https://railsai.com?utm_source=anthropic&utm_medium=readme&utm_id=26072023)
+You can get access to the API [here](https://docs.anthropic.com/claude/docs/getting-access-to-claude).
 
 [🎮 Ruby AI Builders Discord](https://discord.gg/k4Uc224xVD) | [🐦 Twitter](https://twitter.com/alexrudall) | [🤖 OpenAI Gem](https://github.com/alexrudall/ruby-openai) | [🚂 Midjourney Gem](https://github.com/alexrudall/midjourney)
 
@@ -135,6 +133,116 @@ response = client.messages(
 # => }
 ```
 
+#### Additional parameters
+
+You can add other parameters to the parameters hash, like `temperature` and even `top_k` or `top_p`. They will just be passed to the Anthropic server. You
+can read more about the supported parameters [here](https://docs.anthropic.com/claude/reference/messages_post).
+
+There are two special parameters, though, to do with... streaming. Keep reading to find out more.
+
+#### JSON
+
+If you want your output to be json, it is recommended to provide an additional message like this:
+
+```ruby
+[{ role: "user", content: "Give me the heights of the 3 tallest mountains. Answer in the provided JSON format. Only include JSON." },
+{ role: "assistant", content: '[{"name": "Mountain Name", "height": "height in km"}]' }]
+```
+
+Then Claude v3, even Haiku, might respond with:
+
+```ruby
+[{"name"=>"Mount Everest", "height"=>"8.85 km"}, {"name"=>"K2", "height"=>"8.61 km"}, {"name"=>"Kangchenjunga", "height"=>"8.58 km"}]
+```
+
+### Streaming
+
+There are two modes of streaming: raw and preprocessed. The default is raw. You can call it like this:
+
+```ruby
+client.messages(
+  parameters: {
+    model: "claude-3-haiku-20240307",
+    messages: [{ role: "user", content: "How high is the sky?" }],
+    max_tokens: 50,
+    stream: Proc.new { |chunk| print chunk }
+  }
+)
+```
+
+This still returns a regular response at the end, but also gives you direct access to every single chunk returned by Anthropic as they come in. Even if you don't want to
+use the streaming, you may find this useful to avoid timeouts, which can happen if you send Opus a large input context, and expect a long response... It has been known to take
+several minutes to compile the full response - which is longer than our 120 second default timeout. But when streaming, the connection does not time out.
+
+Here is an example of a stream you might get back:
+
+```ruby
+{"type"=>"message_start", "message"=>{"id"=>"msg_01WMWvcZq5JEMLf6Jja4Bven", "type"=>"message", "role"=>"assistant", "model"=>"claude-3-haiku-20240307", "stop_sequence"=>nil, "usage"=>{"input_tokens"=>13, "output_tokens"=>1}, "content"=>[], "stop_reason"=>nil}}
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>"There"}}
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>" is"}}
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>" no"}}
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>" single"}}
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>" defin"}}
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>"itive"}}
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>" \""}}
+...
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>"'s"}}
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>" atmosphere"}}
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>" extends"}}
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>" up"}}
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>" to"}}
+{"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>" about"}}
+{"type"=>"content_block_stop", "index"=>0}
+{"type"=>"message_delta", "delta"=>{"stop_reason"=>"max_tokens", "stop_sequence"=>nil}, "usage"=>{"output_tokens"=>50}}
+{"type"=>"message_stop"}
+```
+
+Now, you may find this... somewhat less than practical. Surely, the vast majority of developers will not want to deal with so much
+boilerplate json.
+
+Luckily, you can ask the anthropic gem to preprocess things for you!
+
+First, if you expect simple text output, you can receive it delta by delta:
+
+```ruby
+client.messages(
+  parameters: {
+    model: "claude-3-haiku-20240307",
+    messages: [{ role: "user", content: "How high is the sky?" }],
+    max_tokens: 50,
+    stream: Proc.new { |incremental_response, delta| process_your(incremental_response, delta) },
+    preprocess_stream: :text
+  }
+)
+```
+
+The first block argument, `incremental_response`, accrues everything that's been returned so far, so you don't have to. If you just want the last bit,
+then use the second, `delta` argument.
+
+But what if you want to stream JSON?
+
+Partial JSON is not very useful. But it is common enough to request a collection of JSON objects as a response, as in our earlier example of asking for the heights of the 3 tallest mountains.
+
+If you ask it to, this gem will also do its best to sort this out for you:
+
+```ruby
+client.messages(
+  parameters: {
+    model: "claude-3-haiku-20240307",
+    messages: [{ role: "user", content: "How high is the sky?" }],
+    max_tokens: 50,
+    stream: Proc.new { |json_object| process_your(json_object) },
+    preprocess_stream: :json
+  }
+)
+```
+
+Each time a `}` is reached in the stream, the preprocessor will take what it has in the preprocessing stack, pick out whatever's between the widest `{` and `}`, and try to parse it into a JSON object.
+If it succeeds, it will pass you the json object, reset its preprocessing stack, and carry on.
+
+If the parsing fails despite reaching a `}`, currently, it will catch the Error, log it to `$stdout`, ignore the malformed object, reset the preprocessing stack and carry on. This does mean that it is possible,
+if the AI is sending some malformed JSON (which can happen, albeit rarely), that some objects will be lost.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can run `bin/console` for an interactive prompt that will allow you to experiment.

data/anthropic.gemspec

@@ -25,6 +25,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "event_stream_parser", ">= 0.3.0", "< 2.0.0"
   spec.add_dependency "faraday", ">= 1"
   spec.add_dependency "faraday-multipart", ">= 1"
 end

data/lib/anthropic/client.rb

@@ -1,27 +1,75 @@
 module Anthropic
   class Client
-    extend Anthropic::HTTP
+    include Anthropic::HTTP
 
-    def initialize(access_token: nil, organization_id: nil, uri_base: nil, request_timeout: nil,
-                   extra_headers: {})
-      Anthropic.configuration.access_token = access_token if access_token
-      Anthropic.configuration.organization_id = organization_id if organization_id
-      Anthropic.configuration.uri_base = uri_base if uri_base
-      Anthropic.configuration.request_timeout = request_timeout if request_timeout
-      Anthropic.configuration.extra_headers = extra_headers
+    CONFIG_KEYS = %i[
+      access_token
+      anthropic_version
+      api_version
+      uri_base
+      request_timeout
+      extra_headers
+    ].freeze
+
+    def initialize(config = {}, &faraday_middleware)
+      CONFIG_KEYS.each do |key|
+        # Set instance variables like api_type & access_token. Fall back to global config
+        # if not present.
+        instance_variable_set(
+          "@#{key}",
+          config[key].nil? ? Anthropic.configuration.send(key) : config[key]
+        )
+      end
+      @faraday_middleware = faraday_middleware
     end
 
+    # @deprecated (but still works while Anthropic API responds to it)
     def complete(parameters: {})
       parameters[:prompt] = wrap_prompt(prompt: parameters[:prompt])
-      Anthropic::Client.json_post(path: "/complete", parameters: parameters)
+      json_post(path: "/complete", parameters: parameters)
     end
 
+    # Anthropic API Parameters as of 2024-05-07:
+    #   @see https://docs.anthropic.com/claude/reference/messages_post
+    #
+    # @param [Hash] parameters
+    # @option parameters [Array] :messages - Required. An array of messages to send to the API. Each
+    #   message should have a role and content. Single message example:
+    #   +[{ role: "user", content: "Hello, Claude!" }]+
+    # @option parameters [String] :model - see https://docs.anthropic.com/claude/docs/models-overview
+    # @option parameters [Integer] :max_tokens - Required, must be less than 4096 - @see https://docs.anthropic.com/claude/docs/models-overview
+    # @option parameters [String] :system - Optional but recommended. @see https://docs.anthropic.com/claude/docs/system-prompts
+    # @option parameters [Float] :temperature - Optional, defaults to 1.0
+    # @option parameters [Proc] :stream - Optional, if present, must be a Proc that will receive the
+    #   content fragments as they come in
+    # @option parameters [String] :preprocess_stream - If true, the streaming Proc will be pre-
+    #   processed. Specifically, instead of being passed a raw Hash like:
+    #   {"type"=>"content_block_delta", "index"=>0, "delta"=>{"type"=>"text_delta", "text"=>" of"}}
+    #   the Proc will instead be passed something nicer. If +preprocess_stream+ is set to +"json"+
+    #   or +:json+, then the Proc will only receive full json objects, one at a time.
+    #   If +preprocess_stream+ is set to +"text"+ or +:text+ then the Proc will receive two
+    #   arguments: the first will be the text accrued so far, and the second will be the delta
+    #   just received in the current chunk.
+    #
+    # @returns [Hash] the response from the API (after the streaming is done, if streaming)
+    #   @example:
+    # {
+    #   "id" => "msg_013xVudG9xjSvLGwPKMeVXzG",
+    #   "type" => "message",
+    #   "role" => "assistant",
+    #   "content" => [{"type" => "text", "text" => "The sky has no distinct"}],
+    #   "model" => "claude-2.1",
+    #   "stop_reason" => "max_tokens",
+    #   "stop_sequence" => nil,
+    #   "usage" => {"input_tokens" => 15, "output_tokens" => 5}
+    # }
     def messages(parameters: {})
-      Anthropic::Client.json_post(path: "/messages", parameters: parameters)
+      json_post(path: "/messages", parameters: parameters)
     end
 
     private
 
+    # Used only by @deprecated +complete+ method
     def wrap_prompt(prompt:, prefix: "\n\nHuman: ", suffix: "\n\nAssistant:")
       return if prompt.nil?
 

data/lib/anthropic/http.rb

@@ -1,23 +1,40 @@
+require "event_stream_parser"
+
+require_relative "http_headers"
+
+# rubocop:disable Metrics/ModuleLength
 module Anthropic
   module HTTP
+    include HTTPHeaders
+
+    # Unused?
     def get(path:)
       to_json(conn.get(uri(path: path)) do |req|
         req.headers = headers
       end&.body)
     end
 
+    # This is currently the workhorse for all API calls.
+    # rubocop:disable Metrics/MethodLength
     def json_post(path:, parameters:)
-      to_json(conn.post(uri(path: path)) do |req|
+      str_resp = {}
+      response = conn.post(uri(path: path)) do |req|
         if parameters[:stream].is_a?(Proc)
-          req.options.on_data = to_json_stream(user_proc: parameters[:stream])
+          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&.body)
+      end
+
+      str_resp.empty? ? response.body : str_resp
     end
+    # rubocop:enable Metrics/MethodLength
 
+    # Unused?
     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" })
@@ -25,6 +42,7 @@ module Anthropic
       end&.body)
     end
 
+    # Unused?
     def delete(path:)
       to_json(conn.delete(uri(path: path)) do |req|
         req.headers = headers
@@ -33,6 +51,7 @@ module Anthropic
 
     private
 
+    # Used only by unused methods?
     def to_json(string)
       return unless string
 
@@ -44,41 +63,119 @@ module Anthropic
 
     # 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.
-    #
-    # If the JSON object for a given data or error message is invalid, it is ignored.
+    # be a data object or an error object as described in the OpenAI 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.
-    def to_json_stream(user_proc:)
-      proc do |chunk, _|
-        chunk.scan(/(?:data|error): (\{.*\})/i).flatten.each do |data|
-          user_proc.call(JSON.parse(data))
-        rescue JSON::ParserError
-          # Ignore invalid 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|
+        handle_faraday_error(chunk, 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)
+        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)
+      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 JSON Error (spotted in ruby-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)
-      Faraday.new do |f|
-        f.options[:timeout] = Anthropic.configuration.request_timeout
+      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
 
-    def headers
-      {
-        "Content-Type" => "application/json",
-        "x-api-key" => Anthropic.configuration.access_token,
-        "Anthropic-Version" => Anthropic.configuration.anthropic_version
-      }.merge(Anthropic.configuration.extra_headers)
-    end
-
+    # Unused except by unused method
     def multipart_parameters(parameters)
       parameters&.transform_values do |value|
         next value unless value.is_a?(File)
@@ -89,5 +186,12 @@ module Anthropic
         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
+      #   openai_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/version.rb

@@ -1,3 +1,3 @@
 module Anthropic
-  VERSION = "0.2.0".freeze
+  VERSION = "0.3.0".freeze
 end

data/lib/anthropic.rb

@@ -9,9 +9,25 @@ 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 ruby-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, :organization_id,
+    attr_accessor :anthropic_version, :api_version, :extra_headers,
                   :request_timeout, :uri_base
 
     DEFAULT_API_VERSION = "v1".freeze
@@ -23,9 +39,9 @@ module Anthropic
       @access_token = nil
       @api_version = DEFAULT_API_VERSION
       @anthropic_version = DEFAULT_ANTHROPIC_VERSION
-      @organization_id = nil
       @uri_base = DEFAULT_URI_BASE
       @request_timeout = DEFAULT_REQUEST_TIMEOUT
+      @extra_headers = {}
     end
 
     def access_token

metadata

@@ -1,15 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: anthropic
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Alex
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-25 00:00:00.000000000 Z
+date: 2024-06-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
@@ -67,6 +87,7 @@ files:
 - lib/anthropic/client.rb
 - lib/anthropic/compatibility.rb
 - lib/anthropic/http.rb
+- lib/anthropic/http_headers.rb
 - lib/anthropic/version.rb
 - lib/ruby/anthropic.rb
 - pull_request_template.md
@@ -93,7 +114,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
+rubygems_version: 3.5.11
 signing_key:
 specification_version: 4
 summary: "Anthropic API + Ruby! \U0001F916\U0001F30C"