anthropic-rb 0.4.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5e066105f3157621c27e2f974ed43bde9f14e6e55187d1d7a4f095b79a5a1ba
-  data.tar.gz: f32d479f7ec06c29a0347f69084a4378a64d69233d78ed280f5a1c924e15d708
+  metadata.gz: 0e743c686b28964af68a40c2e322caf6986284e2922d93d5acc0e2783128a5e5
+  data.tar.gz: 6ae03121d9cae81f15abdacb69a119428a9780f629fde7985a1a22be60192ea4
 SHA512:
-  metadata.gz: 90040c86504a3dfd28e0093d1b8525252387f4e978271908aa158d1cffe10a3dd5766aadc243bc31f45ca6dd38ecf1259d009b2da9f2f78670fcc114c76574a3
-  data.tar.gz: 8ca46c62fe204b3b2403cce1267b6661f43c52159c8d31877b9d2522be604427996eedcbac67ba22a1b6df703259ededd98ea2b86d49755d7aa057835458321c
+  metadata.gz: 352230790e752e44670cb9328b6f93139c1b5c6be9717b65996f1571a34acc9fd7fb28047bddcb32e5ce0c1826faeecb8364d9fd52ace649df868aad86428f9d
+  data.tar.gz: 2d94f8ac749b7d87d2081d2733a5fa52a0771a3dac3a7347af36ae3c40451b9c76362e8dc45540fb060b8c66d79c3fb3c7b351e08fedb489378758c84f9fc81e

data/.reek.yml

@@ -4,10 +4,19 @@ detectors:
       - Anthropic#self.api_key=
   TooManyStatements:
     exclude:
-      - 'Anthropic::Client#self.post'
-  BooleanParameter:
-    exclude:
-      - 'Anthropic::Messages#initialize'
+      - 'Anthropic::Api::Concerns::Validatable#schema'
+      - 'Anthropic::Api::Base#beta_config'
+      - 'Anthropic::Api::Base#version_config'
+      - 'Anthropic::Bootstrapper#self.load_betas'
+      - 'Anthropic::Bootstrapper#self.load_versions'
+      - 'Anthropic::Client::Standard#self.post'
+      - 'Anthropic::Client::Streaming#self.post'
   DuplicateMethodCall:
     exclude:
-      - 'Anthropic::Messages#create'
+      - 'Anthropic::Api::Base#version_config'
+  InstanceVariableAssumption:
+    exclude:
+      - 'Anthropic::Api::Base'
+  NestedIterators:
+    exclude:
+      - 'Anthropic::Bootstrapper#self.load_versions'

data/.rubocop.yml

@@ -4,7 +4,7 @@ require:
   - rubocop-rspec
 
 AllCops:
-  TargetRubyVersion: 3.1
+  TargetRubyVersion: 3.2
   NewCops: enable
 Naming/RescuedExceptionsVariableName:
   Enabled: false

data/.tool-versions

@@ -1 +1 @@
-ruby 3.1.4
+ruby 3.2.4

data/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 ## [Unreleased]
 
+## [0.6.0] - 2024-06-25
+
+### Breaking Changes
+
+- Responses from the Anthropic API are now encapsulated as data objects.
+- Dropped support for Ruby versions prior to 3.2.4.
+
+### Added
+
+- Added link to `anthropic-rb-cookbook`.
+
+### Removed
+
+- Removed streaming contraint for tools use.
+
+### Updated
+
+- Refactored project for maintainability.
+- Updated project funding.
+
+## [0.5.0] - 2024-04-22
+
+### Updated
+
+- Refactored project for maintainability.
+
+### Breaking Changes
+
+- You must now pass the beta ID when enabling a beta feature. The only current beta is for Tools (id: tools-2024-04-04). Previously, you would pass `true` to enable the beta.
+
 ## [0.4.0] - 2024-04-20
 
 ### Added
@@ -57,7 +87,9 @@
 
 - Initial release
 
-[Unreleased]: https://github.com/dickdavis/anthropic-rb/compare/v0.4.0...HEAD
+[Unreleased]: https://github.com/dickdavis/anthropic-rb/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/dickdavis/anthropic-rb/compare/v0.5.0...v0.6.0
+[0.5.0]: https://github.com/dickdavis/anthropic-rb/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/dickdavis/anthropic-rb/compare/v0.3.0...v0.4.0
 [0.3.0]: https://github.com/dickdavis/anthropic-rb/compare/v0.2.5...v0.3.0
 [0.2.5]: https://github.com/dickdavis/anthropic-rb/compare/v0.2.3...v0.2.5

data/README.md

@@ -4,6 +4,8 @@ Ruby bindings for the Anthropic API. This library is unofficial and is not affil
 
 The goal of this project is feature parity with Anthropic's Python SDK until an official Ruby SDK is available.
 
+You can find examples of usage in the [anthropic-rb-cookbook](https://github.com/dickdavis/anthropic-rb-cookbook/).
+
 ## Usage
 
 anthropic-rb will default to the value of the `ANTHROPIC_API_KEY` environment variable. However, you may initialize the library with your API key. You must set your API key before using the library.
@@ -34,35 +36,61 @@ You can send a request to the Messages API.
 Anthropic.messages.create(model: 'claude-2.1', max_tokens: 200, messages: [{role: 'user', content: 'Yo what up?'}])
 
 # Output =>
-# {
-#   id: "msg_013ePdwEkb4RMC1hCE61Hbm8",
-#   type: "message",
-#   role: "assistant",
-#   content: [{type: "text", text: "Hello! Not much up with me, just chatting. How about you?"}],
-#   model: "claude-2.1",
-#   stop_reason: "end_turn",
-#   stop_sequence: nil
-# }
+#<data Anthropic::Client::Response status="success", body={:id=>"msg_01UqHiw6oFLjMYiLV8hkXsrR", :type=>"message", :role=>"assistant", :model=>"claude-2.1", :content=>[{:type=>"text", :text=>"Hello! Not much up with me, just chatting with you. How's it going?"}], :stop_reason=>"end_turn", :stop_sequence=>nil, :usage=>{:input_tokens=>13, :output_tokens=>22}}>
 ```
 
 Alternatively, you can stream the response:
 
 ```ruby
-Anthropic.messages.create(model: 'claude-2.1', max_tokens: 200, messages: [{role: 'user', content: 'Yo what up?'}], stream: true) do |event|
+options = {
+  model: 'claude-2.1',
+  max_tokens: 200,
+  messages: [{role: 'user', content: 'Yo what up?'}],
+  stream: true
+}
+
+Anthropic.messages.create(**options) do |event|
   puts event
 end
 
 # Output =>
-# { type: 'message_start', message: { id: 'msg_012pkeozZynwyNvSagwL7kMw', type: 'message', role: 'assistant', content: [], model: 'claude-2.1', stop_reason: nil, stop_sequence: nil } }
-# { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } }
-# { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: 'Hello' } }
-# { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: '.' } }
-# { type: 'content_block_stop', index: 0 }
-# { type: 'message_delta', delta: { stop_reason: 'end_turn', stop_sequence: nil } }
-# { type: 'message_stop' }
+#<data Anthropic::Client::Response status="success", body={:type=>"message_start", :message=>{:id=>"msg_01EsYcQkBJrHrtgpY5ZcLzvf", :type=>"message", :role=>"assistant", :model=>"claude-2.1", :content=>[], :stop_reason=>nil, :stop_sequence=>nil, :usage=>{:input_tokens=>13, :output_tokens=>1}}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_start", :index=>0, :content_block=>{:type=>"text", :text=>""}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>"Hello"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>"!"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>" Not"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>" much"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>" up"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>" with"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>" me"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>","}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>" I"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>"'m"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>" an"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>" AI"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>" assistant"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>" create"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>"d by"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>" An"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>"throp"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>"ic"}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_delta", :index=>0, :delta=>{:type=>"text_delta", :text=>"."}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"content_block_stop", :index=>0}>
+#<data Anthropic::Client::Response status="success", body={:type=>"message_delta", :delta=>{:stop_reason=>"end_turn", :stop_sequence=>nil}, :usage=>{:output_tokens=>23}}>
+#<data Anthropic::Client::Response status="success", body={:type=>"message_stop"}>
+
+# Or, if you just want to print the text content:
+Anthropic.messages.create(**options) do |event|
+  next unless event.body[:type] == 'content_block_delta'
+
+  print event.body[:delta][:text]
+end
+
+# Output =>
+# Hello! Not much up with me, I'm an AI assistant created by Anthropic.
 ```
 
-You can also experiment with the new tools beta by passing the `beta` flag when calling the API. This will ensure each request includes the correct beta header.
+You can also pass in a list of tools the assistant can use. You can find out more information about tools in the [documentation](https://docs.anthropic.com/claude/docs/tool-use).
 
 ```ruby
 tools = [
@@ -79,7 +107,7 @@ tools = [
   }
 ]
 
-Anthropic.messages(beta: true).create(
+Anthropic.messages.create(
   model: 'claude-3-opus-20240229',
   max_tokens: 200,
   tools:,
@@ -87,8 +115,6 @@ Anthropic.messages(beta: true).create(
 )
 ```
 
-Streaming is currently not supported by the tools beta. You can find out more information about tools in the [documentation](https://docs.anthropic.com/claude/docs/tool-use).
-
 ### Completions API
 
 To make a request to the Completions API:
@@ -101,38 +127,41 @@ Anthropic.completions.create(
 )
 
 # Output =>
-# {
-#   completion: "Hello! Not much going on with me, just chatting. How about you?",
-#   stop_reason: "stop_sequence",
-#   model: "claude-2.1",
-#   stop: "\n\nHuman:",
-#   log_id: "2496914137c520ec2b4ae8315864bcf3a4c6ce9f2e3c96e13be4c004587313ca"
-# }
+#<data Anthropic::Client::Response status="success", body={:type=>"completion", :id=>"compl_01Y9ptPR7xGHaH9rC3ffJExU", :completion=>" Hello! Not much going on here. How about you?", :stop_reason=>"stop_sequence", :model=>"claude-2.1", :stop=>"\n\nHuman:", :log_id=>"compl_01Y9ptPR7xGHaH9rC3ffJExU"}>
 ```
 
 Alternatively, you can stream the response:
 
 ```ruby
-Anthropic.completions.create(model: 'claude-2', max_tokens_to_sample: 200, prompt: 'Human: Yo what up?\n\nAssistant:', stream: true) do |event|
+options = {
+  model: 'claude-2',
+  max_tokens_to_sample: 200,
+  prompt: 'Human: Yo what up?\n\nAssistant:',
+  stream: true
+}
+
+Anthropic.completions.create(**options) do |event|
   puts event
 end
 
 # Output =>
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: ' Hello', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: '!', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: ' Not', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: ' much', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: ',', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: ' just', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: ' chatting', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: ' with', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: ' people', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: '.', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: ' How', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: ' about', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: ' you', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: '?', stop_reason: nil, model: 'claude-2.1', stop: nil, log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
-# { type: 'completion', id: 'compl_01G6cEfdZtLEEJVRzwUShiDY', completion: '', stop_reason: 'stop_sequence', model: 'claude-2.1', stop: "\n\nHuman:", log_id: 'compl_01G6cEfdZtLEEJVRzwUShiDY' }
+#<data Anthropic::Client::Response status="success", body={:type=>"completion", :id=>"compl_015AktggW7tcM4w11YpkuMbP", :completion=>" Hello", :stop_reason=>nil, :model=>"claude-2.1", :stop=>nil, :log_id=>"compl_015AktggW7tcM4w11YpkuMbP"}>
+#<data Anthropic::Client::Response status="success", body={:type=>"completion", :id=>"compl_015AktggW7tcM4w11YpkuMbP", :completion=>"!", :stop_reason=>nil, :model=>"claude-2.1", :stop=>nil, :log_id=>"compl_015AktggW7tcM4w11YpkuMbP"}>
+#<data Anthropic::Client::Response status="success", body={:type=>"completion", :id=>"compl_015AktggW7tcM4w11YpkuMbP", :completion=>" Not", :stop_reason=>nil, :model=>"claude-2.1", :stop=>nil, :log_id=>"compl_015AktggW7tcM4w11YpkuMbP"}>
+#<data Anthropic::Client::Response status="success", body={:type=>"completion", :id=>"compl_015AktggW7tcM4w11YpkuMbP", :completion=>" much", :stop_reason=>nil, :model=>"claude-2.1", :stop=>nil, :log_id=>"compl_015AktggW7tcM4w11YpkuMbP"}>
+#<data Anthropic::Client::Response status="success", body={:type=>"completion", :id=>"compl_015AktggW7tcM4w11YpkuMbP", :completion=>" going", :stop_reason=>nil, :model=>"claude-2.1", :stop=>nil, :log_id=>"compl_015AktggW7tcM4w11YpkuMbP"}>
+#<data Anthropic::Client::Response status="success", body={:type=>"completion", :id=>"compl_015AktggW7tcM4w11YpkuMbP", :completion=>" on", :stop_reason=>nil, :model=>"claude-2.1", :stop=>nil, :log_id=>"compl_015AktggW7tcM4w11YpkuMbP"}>
+#<data Anthropic::Client::Response status="success", body={:type=>"completion", :id=>"compl_015AktggW7tcM4w11YpkuMbP", :completion=>" here", :stop_reason=>nil, :model=>"claude-2.1", :stop=>nil, :log_id=>"compl_015AktggW7tcM4w11YpkuMbP"}>
+#<data Anthropic::Client::Response status="success", body={:type=>"completion", :id=>"compl_015AktggW7tcM4w11YpkuMbP", :completion=>".", :stop_reason=>nil, :model=>"claude-2.1", :stop=>nil, :log_id=>"compl_015AktggW7tcM4w11YpkuMbP"}>
+#<data Anthropic::Client::Response status="success", body={:type=>"completion", :id=>"compl_015AktggW7tcM4w11YpkuMbP", :completion=>"", :stop_reason=>"stop_sequence", :model=>"claude-2.1", :stop=>"\n\nHuman:", :log_id=>"compl_015AktggW7tcM4w11YpkuMbP"}>
+
+# Or, if you just want to print the text content:
+Anthropic.completions.create(**options) do |event|
+  print event.body[:completion]
+end
+
+# Output =>
+# Hello! Not much, just chatting with you. How's it going?
 ```
 
 ## Installation
@@ -161,6 +190,8 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`.
 
+To run a sanity check, run `ruby sanity_check.rb`.
+
 To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 ## Contributing

data/lib/anthropic/api/base.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'concerns/requestable'
+require_relative 'concerns/validatable'
+
+module Anthropic
+  module Api
+    # Error for when a beta feature is configured incorrectly.
+    class InvalidBetaConfigurationError < StandardError; end
+
+    # Error for when API version is missing a schema.
+    class MissingSchemaError < StandardError; end
+
+    # Error for when the provided params do not match the API schema
+    class SchemaValidationError < StandardError; end
+
+    # Error for when the API version is not supported.
+    class UnsupportedApiVersionError < StandardError; end
+
+    # Error for when the provided beta is not supported.
+    class UnsupportedBetaError < StandardError; end
+
+    ##
+    # Provides a base class for APIs
+    class Base
+      include Anthropic::Api::Concerns::Requestable
+      include Anthropic::Api::Concerns::Validatable
+
+      def initialize(beta: nil)
+        @beta = beta
+      end
+
+      private
+
+      attr_reader :beta
+
+      def api
+        self.class.name.split('::').last.downcase
+      end
+
+      def version_config
+        return @version_config if defined?(@version_config)
+
+        @version_config ||= catch(:version_found) do
+          found_config = Anthropic.versions[api.to_sym].find { |config| config['version'] == Anthropic.api_version }
+          unless found_config
+            raise Anthropic::Api::UnsupportedApiVersionError, "Unsupported API version: #{Anthropic.api_version}"
+          end
+
+          throw :version_found, found_config
+        end
+      end
+
+      def beta_config
+        return @beta_config if defined?(@beta_config)
+
+        @beta_config = catch(:beta_found) do
+          found_config = Anthropic.betas.find { |config| config['id'] == beta }
+          raise Anthropic::Api::UnsupportedBetaError, "#{beta} not supported" unless found_config
+
+          throw :beta_found, found_config
+        end
+      end
+
+      def beta_loaded?(name)
+        return false unless beta
+
+        beta_config['id'] == name
+      end
+    end
+  end
+end

data/lib/anthropic/api/completions.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Api
+    ##
+    # Provides bindings for the Anthropic completions API
+    class Completions < Base
+      def create(**params, &)
+        validate!(params)
+        return post(params) unless params[:stream]
+
+        post_as_stream(params, &)
+      end
+    end
+  end
+end

data/lib/anthropic/api/concerns/requestable.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Api
+    module Concerns
+      ##
+      # Provides helpers for sending API requests
+      module Requestable
+        def post(params)
+          Anthropic::Client::Standard.post(uri, params, additional_headers)
+        end
+
+        def post_as_stream(params, &)
+          Anthropic::Client::Streaming.post(uri, params, additional_headers, &)
+        end
+
+        def uri
+          "#{Anthropic.api_host}#{version_config['endpoint']}"
+        end
+
+        def additional_headers
+          {}.merge(beta_headers)
+        end
+
+        def beta_headers
+          return {} unless beta
+
+          header = beta_config['header']
+          raise Anthropic::Api::InvalidBetaConfigurationError, "Missing header: #{beta}" unless header
+
+          header
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/api/concerns/validatable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Api
+    module Concerns
+      ##
+      # Provides helpers for validating params against the API schema
+      module Validatable
+        def validate!(params)
+          JSON::Validator.validate!(schema, params)
+        rescue JSON::Schema::ValidationError => error
+          raise Anthropic::Api::SchemaValidationError, error.message
+        end
+
+        def schema
+          api_schema = version_config['schema']
+
+          unless api_schema
+            raise Anthropic::Api::MissingSchemaError, "Missing schema for API version: #{Anthropic.api_version}"
+          end
+
+          if beta
+            beta_schema = beta_config['schema']
+            raise Anthropic::Api::InvalidBetaConfigurationError, "Missing beta schema: #{beta}" unless beta_schema
+
+            api_schema['properties'].merge!(beta_schema)
+          end
+
+          api_schema
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/api/messages.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Api
+    ##
+    # Provides bindings for the Anthropic messages API
+    class Messages < Base
+      def create(**params, &)
+        validate!(params)
+        return post(params) unless params[:stream]
+
+        post_as_stream(params, &)
+      end
+    end
+  end
+end

data/lib/anthropic/bootstrapper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'httpx'
+
+module Anthropic
+  ##
+  # Provides methods for bootstrapping the Anthropic gem
+  module Bootstrapper
+    def self.load_betas
+      directory_path = File.expand_path('../../schemas/betas', __dir__)
+      raise "Directory not found: #{directory_path}" unless Dir.exist?(directory_path)
+
+      file_paths = Dir.glob(File.join(directory_path, '*.json'))
+
+      file_paths.map do |file_path|
+        JSON.parse(File.read(file_path))
+      end
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def self.load_versions
+      directory_path = File.expand_path('../../schemas/versions', __dir__)
+      raise "Directory not found: #{directory_path}" unless Dir.exist?(directory_path)
+
+      versions = {}
+
+      Dir.glob(File.join(directory_path, '*')).each do |subdirectory_path|
+        next unless File.directory?(subdirectory_path)
+
+        subdirectory_name = File.basename(subdirectory_path)
+        file_paths = Dir.glob(File.join(subdirectory_path, '*.json'))
+
+        versions[subdirectory_name.to_sym] = file_paths.map do |file_path|
+          JSON.parse(File.read(file_path))
+        end
+      end
+
+      versions
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+  end
+end

data/lib/anthropic/client/base.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'httpx'
+
+module Anthropic
+  module Client
+    ##
+    # Error when the server experienced an internal error.
+    class ApiError < StandardError; end
+
+    ##
+    # Error when the API key is invalid.
+    class AuthenticationError < StandardError; end
+
+    ##
+    # Error when the resource already exists.
+    class ConflictError < StandardError; end
+
+    ##
+    # Error when the request is malformed.
+    class InvalidRequestError < StandardError; end
+
+    ##
+    # Error when the resource is not found.
+    class NotFoundError < StandardError; end
+
+    ##
+    # Error when the API servers are overloaded.
+    class OverloadedError < StandardError; end
+
+    ##
+    # Error when the account does not have permission for the operation.
+    class PermissionError < StandardError; end
+
+    ##
+    # Error when the request exceeds the rate limit.
+    class RateLimitError < StandardError; end
+
+    ##
+    # Error when the resource cannot be processed.
+    class UnprocessableEntityError < StandardError; end
+
+    ##
+    # Defines a data object for responses
+    Response = Data.define(:status, :body)
+
+    ##
+    # Provides a base class for clients
+    class Base
+      class << self
+        private
+
+        def build_response(response)
+          response_hash = JSON.parse(response, symbolize_names: true)
+          status = response_hash[:type] == 'error' ? 'failure' : 'success'
+          Anthropic::Client::Response.new(status:, body: response_hash)
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/client/standard.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Client
+    ##
+    # Provides a client for sending standard HTTP requests.
+    class Standard < Base
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+      def self.post(url, data, headers = {})
+        response = HTTPX.with(
+          headers: {
+            'Content-Type' => 'application/json',
+            'x-api-key' => Anthropic.api_key,
+            'anthropic-version' => Anthropic.api_version
+          }.merge(headers)
+        ).post(url, json: data)
+
+        response_data = build_response(response.body)
+
+        case response.status
+        when 200
+          response_data
+        when 400
+          raise Anthropic::Client::InvalidRequestError, response_data
+        when 401
+          raise Anthropic::Client::AuthenticationError, response_data
+        when 403
+          raise Anthropic::Client::PermissionError, response_data
+        when 404
+          raise Anthropic::Client::NotFoundError, response_data
+        when 409
+          raise Anthropic::Client::ConflictError, response_data
+        when 422
+          raise Anthropic::Client::UnprocessableEntityError, response_data
+        when 429
+          raise Anthropic::Client::RateLimitError, response_data
+        when 500
+          raise Anthropic::Client::ApiError, response_data
+        when 529
+          raise Anthropic::Client::OverloadedError, response_data
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
+    end
+  end
+end

data/lib/anthropic/client/streaming.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Client
+    ##
+    # Provides a client for sending streaming HTTP requests.
+    class Streaming < Base
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      def self.post(url, data, headers = {})
+        response = HTTPX.plugin(:stream).with(
+          headers: {
+            'Content-Type' => 'application/json',
+            'x-api-key' => Anthropic.api_key,
+            'anthropic-version' => Anthropic.api_version
+          }.merge(headers)
+        ).post(url, json: data, stream: true)
+
+        response.each_line do |line|
+          type, event = line.split(/(\w+\b:\s)/)[1..2]
+          next unless type&.start_with?('data') && event
+
+          response_data = build_response(event)
+          yield response_data unless %w[ping error].include?(response_data.body[:type])
+        end
+      rescue HTTPX::HTTPError => error
+        case error.response.status
+        when 400
+          raise Anthropic::Client::InvalidRequestError
+        when 401
+          raise Anthropic::Client::AuthenticationError
+        when 403
+          raise Anthropic::Client::PermissionError
+        when 404
+          raise Anthropic::Client::NotFoundError
+        when 409
+          raise Anthropic::Client::ConflictError
+        when 422
+          raise Anthropic::Client::UnprocessableEntityError
+        when 429
+          raise Anthropic::Client::RateLimitError
+        when 500
+          raise Anthropic::Client::ApiError
+        when 529
+          raise Anthropic::Client::OverloadedError
+        end
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    end
+  end
+end

data/lib/anthropic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Anthropic
-  VERSION = '0.4.0'
+  VERSION = '0.6.0'
 end

data/lib/anthropic.rb

@@ -4,24 +4,20 @@ require 'httpx'
 require 'json'
 require 'json-schema'
 
-require_relative 'anthropic/client'
-require_relative 'anthropic/completions'
-require_relative 'anthropic/messages'
-require_relative 'anthropic/version'
+Dir[File.join(__dir__, 'anthropic/', '**', '*.rb')].each { |file| require_relative file }
 
 ##
 # Namespace for anthropic-rb gem
 module Anthropic
-  ##
-  # Default error class
-  class Error < StandardError; end
-
   def self.setup
     yield self
+    @betas = Bootstrapper.load_betas
+    @versions = Bootstrapper.load_versions
   end
 
   def self.reset
     @api_key = nil
+    @api_host = nil
     @api_version = nil
   end
 
@@ -33,6 +29,14 @@ module Anthropic
     @api_key = api_key
   end
 
+  def self.api_host
+    @api_host || ENV.fetch('ANTHROPIC_API_HOST', 'https://api.anthropic.com')
+  end
+
+  def self.api_host=(api_host = nil)
+    @api_host = api_host
+  end
+
   def self.api_version
     @api_version || ENV.fetch('ANTHROPIC_API_VERSION', '2023-06-01')
   end
@@ -41,11 +45,19 @@ module Anthropic
     @api_version = api_version
   end
 
+  def self.betas
+    @betas
+  end
+
+  def self.versions
+    @versions
+  end
+
   def self.completions
-    Completions.new
+    Anthropic::Api::Completions.new
   end
 
   def self.messages(...)
-    Messages.new(...)
+    Anthropic::Api::Messages.new(...)
   end
 end

data/sanity_check.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'anthropic'
+
+Anthropic.setup do |config|
+  config.api_key = ENV.fetch('ANTHROPIC_API_KEY')
+end
+
+puts "\nTesting non-streaming messages API"
+puts Anthropic.messages.create(
+  model: 'claude-2.1',
+  max_tokens: 200,
+  messages: [{ role: 'user', content: 'Yo what up?' }]
+)
+
+puts "\nTesting streaming messages API"
+Anthropic.messages.create(
+  model: 'claude-2.1',
+  max_tokens: 200,
+  messages: [{ role: 'user', content: 'Yo what up?' }],
+  stream: true
+) { |event| puts event }
+
+puts "\nTesting tools"
+tools = [
+  {
+    name: 'get_weather',
+    description: 'Get the current weather in a given location',
+    input_schema: {
+      type: 'object',
+      properties: {
+        location: { type: 'string' }
+      },
+      required: ['location']
+    }
+  }
+]
+
+puts Anthropic.messages(beta: 'tools-2024-04-04').create(
+  model: 'claude-3-opus-20240229',
+  max_tokens: 200,
+  tools:,
+  messages: [{ role: 'user', content: 'What is the weather like in Nashville?' }]
+)
+
+puts "\nTesting completions API"
+puts Anthropic.completions.create(
+  model: 'claude-2',
+  max_tokens_to_sample: 200,
+  prompt: 'Human: Yo what up?\n\nAssistant:'
+)
+
+puts "\nTesting streaming completions API"
+Anthropic.completions.create(
+  model: 'claude-2',
+  max_tokens_to_sample: 200,
+  prompt: 'Human: Yo what up?\n\nAssistant:',
+  stream: true
+) { |event| puts event }

data/schemas/betas/tools-2024-04-04.json

@@ -0,0 +1,26 @@
+{
+  "id": "tools-2024-04-04",
+  "name": "[Deprecated] Tools",
+  "description": "[Deprecated] Equips Claude with custom tools for interacting with clients for a wide variety of tasks.",
+  "documentation": "https://docs.anthropic.com/claude/docs/tool-use",
+  "header" : { "anthropic-beta": "tools-2024-04-04"  },
+  "schema": {
+    "tools": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "description": {
+            "type": "string"
+          },
+          "input_schema": {
+            "type": "object"
+          }
+        }
+      }
+    }
+  }
+}

data/schemas/versions/completions/2023-06-01.json

@@ -0,0 +1,45 @@
+{
+  "version": "2023-06-01",
+  "endpoint": "/v1/complete",
+  "schema": {
+    "type": "object",
+    "required": [
+      "model",
+      "prompt",
+      "max_tokens_to_sample"
+    ],
+    "properties": {
+      "model": {
+        "type": "string"
+      },
+      "prompt": {
+        "type": "string"
+      },
+      "max_tokens_to_sample": {
+        "type": "integer"
+      },
+      "stop_sequences": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      },
+      "temperature": {
+        "type": "number"
+      },
+      "top_k": {
+        "type": "integer"
+      },
+      "top_p": {
+        "type": "number"
+      },
+      "metadata": {
+        "type": "object"
+      },
+      "stream": {
+        "type": "boolean"
+      }
+    },
+    "additionalProperties": false
+  }
+}

data/schemas/versions/messages/2023-06-01.json

@@ -0,0 +1,65 @@
+{
+  "version": "2023-06-01",
+  "endpoint": "/v1/messages",
+  "schema": {
+    "type": "object",
+    "required": [
+      "model",
+      "messages",
+      "max_tokens"
+    ],
+    "properties": {
+      "model": {
+        "type": "string"
+      },
+      "messages": {
+        "type": "array"
+      },
+      "max_tokens": {
+        "type": "integer"
+      },
+      "system": {
+        "type": "string"
+      },
+      "stop_sequences": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      },
+      "temperature": {
+        "type": "number"
+      },
+      "tools": {
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string"
+            },
+            "description": {
+              "type": "string"
+            },
+            "input_schema": {
+              "type": "object"
+            }
+          }
+        }
+      },
+      "top_k": {
+        "type": "integer"
+      },
+      "top_p": {
+        "type": "number"
+      },
+      "metadata": {
+        "type": "object"
+      },
+      "stream": {
+        "type": "boolean"
+      }
+    },
+    "additionalProperties": false
+  }
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: anthropic-rb
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Dick Davis
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-20 00:00:00.000000000 Z
+date: 2024-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpx
@@ -54,12 +54,21 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- anthropic-rb.gemspec
 - lib/anthropic.rb
-- lib/anthropic/client.rb
-- lib/anthropic/completions.rb
-- lib/anthropic/messages.rb
+- lib/anthropic/api/base.rb
+- lib/anthropic/api/completions.rb
+- lib/anthropic/api/concerns/requestable.rb
+- lib/anthropic/api/concerns/validatable.rb
+- lib/anthropic/api/messages.rb
+- lib/anthropic/bootstrapper.rb
+- lib/anthropic/client/base.rb
+- lib/anthropic/client/standard.rb
+- lib/anthropic/client/streaming.rb
 - lib/anthropic/version.rb
+- sanity_check.rb
+- schemas/betas/tools-2024-04-04.json
+- schemas/versions/completions/2023-06-01.json
+- schemas/versions/messages/2023-06-01.json
 - sig/anthropic/rb.rbs
 homepage: https://github.com/dickdavis/anthropic-rb
 licenses:
@@ -78,14 +87,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: 3.2.4
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Ruby bindings for the Anthropic API

data/anthropic-rb.gemspec

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lib/anthropic/version'
-
-Gem::Specification.new do |spec|
-  spec.name = 'anthropic-rb'
-  spec.version = Anthropic::VERSION
-  spec.authors = ['Dick Davis']
-  spec.email = ['dick@hey.com']
-
-  spec.summary = 'Ruby bindings for the Anthropic API'
-  spec.homepage = 'https://github.com/dickdavis/anthropic-rb'
-  spec.license = 'MIT'
-
-  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
-  spec.metadata['homepage_uri'] = spec.homepage
-  spec.metadata['source_code_uri'] = 'https://github.com/dickdavis/anthropic-rb'
-  spec.metadata['changelog_uri'] = 'https://github.com/dickdavis/anthropic-rb/blob/main/CHANGELOG.md'
-
-  # Specify which files should be added to the gem when it is released.
-  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files = Dir.chdir(__dir__) do
-    `git ls-files -z`.split("\x0").reject do |f|
-      (File.expand_path(f) == __FILE__) ||
-        f.start_with?(*%w[bin/ spec/ .git .github/ Gemfile])
-    end
-  end
-  spec.bindir = 'exe'
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
-  spec.require_paths = ['lib']
-
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
-  spec.metadata['rubygems_mfa_required'] = 'true'
-
-  spec.required_ruby_version = '>= 3.1'
-  spec.add_dependency 'httpx', '>= 1.1.5'
-  spec.add_dependency 'json-schema', '>= 4.1.1'
-end

data/lib/anthropic/client.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require 'httpx'
-
-module Anthropic
-  ##
-  # Error when the request is malformed.
-  class BadRequestError < StandardError; end
-  ##
-  # Error when the API key is invalid.
-  class AuthenticationError < StandardError; end
-  ##
-  # Error when the account does not have permission for the operation.
-  class PermissionDeniedError < StandardError; end
-  ##
-  # Error when the resource is not found.
-  class NotFoundError < StandardError; end
-  ##
-  # Error when the resource already exists.
-  class ConflictError < StandardError; end
-  ##
-  # Error when the resource cannot be processed.
-  class UnprocessableEntityError < StandardError; end
-  ##
-  # Error when the request exceeds the rate limit.
-  class RateLimitError < StandardError; end
-  ##
-  # Error when the server experienced an internal error.
-  class InternalServerError < StandardError; end
-
-  ##
-  # Provides a client for sending HTTP requests.
-  class Client
-    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
-    def self.post(url, data, headers = {})
-      response = HTTPX.with(
-        headers: {
-          'Content-Type' => 'application/json',
-          'x-api-key' => Anthropic.api_key,
-          'anthropic-version' => Anthropic.api_version
-        }.merge(headers)
-      ).post(url, json: data)
-
-      response_body = JSON.parse(response.body, symbolize_names: true)
-
-      case response.status
-      when 200
-        response_body
-      when 400
-        raise Anthropic::BadRequestError, response_body
-      when 401
-        raise Anthropic::AuthenticationError, response_body
-      when 403
-        raise Anthropic::PermissionDeniedError, response_body
-      when 404
-        raise Anthropic::NotFoundError, response_body
-      when 409
-        raise Anthropic::ConflictError, response_body
-      when 422
-        raise Anthropic::UnprocessableEntityError, response_body
-      when 429
-        raise Anthropic::RateLimitError, response_body
-      when 500
-        raise Anthropic::InternalServerError, response_body
-      end
-    end
-
-    def self.post_as_stream(url, data, headers = {})
-      response = HTTPX.plugin(:stream).with(
-        headers: {
-          'Content-Type' => 'application/json',
-          'x-api-key' => Anthropic.api_key,
-          'anthropic-version' => Anthropic.api_version
-        }.merge(headers)
-      ).post(url, json: data, stream: true)
-
-      response.each_line do |line|
-        event, data = line.split(/(\w+\b:\s)/)[1..2]
-        next unless event && data
-
-        if event.start_with?('data')
-          formatted_data = JSON.parse(data, symbolize_names: true)
-          yield formatted_data unless %w[ping error].include?(formatted_data[:type])
-        end
-      end
-    rescue HTTPX::HTTPError => error
-      case error.response.status
-      when 400
-        raise Anthropic::BadRequestError
-      when 401
-        raise Anthropic::AuthenticationError
-      when 403
-        raise Anthropic::PermissionDeniedError
-      when 404
-        raise Anthropic::NotFoundError
-      when 409
-        raise Anthropic::ConflictError
-      when 422
-        raise Anthropic::UnprocessableEntityError
-      when 429
-        raise Anthropic::RateLimitError
-      when 500
-        raise Anthropic::InternalServerError
-      end
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity
-  end
-end

data/lib/anthropic/completions.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module Anthropic
-  ##
-  # Provides bindings for the Anthropic completions API
-  class Completions
-    # Error for when the API version is not supported.
-    class UnsupportedApiVersionError < StandardError; end
-
-    V1_SCHEMA = {
-      type: 'object',
-      required: %w[model prompt max_tokens_to_sample],
-      properties: {
-        model: { type: 'string' },
-        prompt: { type: 'string' },
-        max_tokens_to_sample: { type: 'integer' },
-        stop_sequences: { type: 'array', items: { type: 'string' } },
-        temperature: { type: 'number' },
-        top_k: { type: 'integer' },
-        top_p: { type: 'number' },
-        metadata: { type: 'object' },
-        stream: { type: 'boolean' }
-      },
-      additionalProperties: false
-    }.freeze
-
-    def initialize
-      @endpoint = 'https://api.anthropic.com/v1/complete'
-    end
-
-    def create(**params, &)
-      JSON::Validator.validate!(schema_for_api_version, params)
-      return Anthropic::Client.post(endpoint, params) unless params[:stream]
-
-      Anthropic::Client.post_as_stream(endpoint, params, &)
-    rescue JSON::Schema::ValidationError => error
-      raise ArgumentError, error.message
-    end
-
-    private
-
-    attr_reader :endpoint
-
-    def schema_for_api_version
-      api_version = Anthropic.api_version
-      case api_version
-      when '2023-06-01'
-        V1_SCHEMA
-      else
-        raise UnsupportedApiVersionError, "Unsupported API version: #{api_version}"
-      end
-    end
-  end
-end

data/lib/anthropic/messages.rb

@@ -1,76 +0,0 @@
-# frozen_string_literal: true
-
-module Anthropic
-  ##
-  # Provides bindings for the Anthropic messages API
-  class Messages
-    # Error for when the API version is not supported.
-    class UnsupportedApiVersionError < StandardError; end
-
-    # Error for when a beta feature is not used correctly
-    class UnsupportedBetaOptionError < StandardError; end
-
-    ENDPOINT = 'https://api.anthropic.com/v1/messages'
-    V1_SCHEMA = {
-      type: 'object',
-      required: %w[model messages max_tokens],
-      properties: {
-        model: { type: 'string' },
-        messages: { type: 'array' },
-        max_tokens: { type: 'integer' },
-        system: { type: 'string' },
-        stop_sequences: { type: 'array', items: { type: 'string' } },
-        temperature: { type: 'number' },
-        tools: {
-          type: 'array',
-          items: {
-            name: { type: 'string' },
-            description: { type: 'string' },
-            input_schema: { type: 'object' }
-          }
-        },
-        top_k: { type: 'integer' },
-        top_p: { type: 'number' },
-        metadata: { type: 'object' },
-        stream: { type: 'boolean' }
-      },
-      additionalProperties: false
-    }.freeze
-
-    def initialize(beta: false)
-      @beta = beta
-    end
-
-    def create(**params, &)
-      raise UnsupportedBetaOptionError, 'Tool use is not yet supported in streaming mode' if params[:stream] && beta
-
-      JSON::Validator.validate!(schema_for_api_version, params)
-
-      return Anthropic::Client.post(ENDPOINT, params, additional_headers) unless params[:stream]
-
-      Anthropic::Client.post_as_stream(ENDPOINT, params, additional_headers, &)
-    rescue JSON::Schema::ValidationError => error
-      raise ArgumentError, error.message
-    end
-
-    private
-
-    attr_reader :beta
-
-    def schema_for_api_version
-      api_version = Anthropic.api_version
-      case api_version
-      when '2023-06-01'
-        V1_SCHEMA
-      else
-        raise UnsupportedApiVersionError, "Unsupported API version: #{api_version}"
-      end
-    end
-
-    def additional_headers
-      return {} unless beta
-
-      { 'anthropic-beta' => 'tools-2024-04-04' }
-    end
-  end
-end