anthropic-sdk-beta 0.1.0.pre.beta.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5c8515cfd945a97cc3072cc7719eae991c2338a19c7893ef9cd8436914f203d5
+  data.tar.gz: b114a1dbe22974e2c590789754a36db627180a55ce6d96803b572c0b61667db7
+SHA512:
+  metadata.gz: 2ae656a378a0e4eab76d38c060fa124456d9e5cf93d22fa5d58bc2a152ef73b999534a59b245abdd206992185ad91f23b2eae33aa502d3e9ccc7f580448da5a8
+  data.tar.gz: 931b74ff3d3d89a44c6b45e72e1b459d60051fa590879936b12904c073236a86c1c93ae756a3e11617641ef16ec624629e857fe529a9f9f0b3c8c006e5245e2a

data/README.md

@@ -0,0 +1,343 @@
+# Anthropic Ruby API library
+
+The Anthropic Ruby library provides convenient access to the Anthropic REST API from any Ruby 3.1.0+ application.
+
+## Documentation
+
+Documentation for released of this gem can be found [on RubyDoc](https://gemdocs.org/gems/anthropic-sdk-beta).
+
+The underlying REST API documentation can be found on [docs.anthropic.com](https://docs.anthropic.com/claude/reference/).
+
+## Installation
+ℹ️ The `anthropic-sdk-beta` gem name is temporary. @alexrudall will be transitioning the [anthropic gem name](https://github.com/alexrudall/anthropic) to this repository. Here's the timeline:
+- Early April, 2025: This library is released under the `anthropic-sdk-beta` gem name. We'll be gathering feedback from the community.
+- Late April/early May: Bump the version `1.0`, and transition the `anthropic` gem name to this repository.
+
+To use this gem, install via Bundler by adding the following to your application's `Gemfile`:
+
+<!-- x-release-please-start-version -->
+
+```ruby
+gem "anthropic-sdk-beta", "~> 0.1.0.pre.beta.3"
+```
+
+<!-- x-release-please-end -->
+
+To fetch an initial copy of the gem:
+
+```sh
+bundle install
+```
+
+## Usage
+
+```ruby
+require "bundler/setup"
+require "anthropic-sdk-beta"
+
+anthropic = Anthropic::Client.new(
+  api_key: "my-anthropic-api-key" # defaults to ENV["ANTHROPIC_API_KEY"]
+)
+
+message =
+  anthropic.messages.create(
+    max_tokens: 1024,
+    messages: [{
+      role: "user",
+      content: "Hello, Claude"
+    }],
+    model: "claude-3-5-sonnet-latest"
+  )
+
+puts(message.content)
+```
+
+### Pagination
+
+List methods in the Anthropic API are paginated.
+
+This library provides auto-paginating iterators with each list response, so you do not have to request successive pages manually:
+
+```ruby
+page = anthropic.beta.messages.batches.list(limit: 20)
+
+# Fetch single item from page.
+batch = page.data[0]
+puts(batch.id)
+
+# Automatically fetches more pages as needed.
+page.auto_paging_each do |batch|
+  puts(batch.id)
+end
+```
+
+### Streaming
+
+We provide support for streaming responses using Server Side Events (SSE).
+
+**coming soon**: `anthropic.messages.stream` will have [Python SDK](https://github.com/anthropics/anthropic-sdk-python?tab=readme-ov-file#streaming-helpers) style streaming response helpers.
+
+```ruby
+stream =
+  anthropic.messages.stream_raw(
+    max_tokens: 1024,
+    messages: [{
+      role: "user",
+      content: "Hello, Claude"
+    }],
+    model: "claude-3-5-sonnet-latest"
+  )
+
+stream.each do |message|
+  puts(message.type)
+end
+```
+
+### Errors
+
+When the library is unable to connect to the API, or if the API returns a non-success status code (i.e., 4xx or 5xx response), a subclass of `Anthropic::Error` will be thrown:
+
+```ruby
+begin
+  message =
+    anthropic.messages.create(
+      max_tokens: 1024,
+      messages: [{
+        role: "user",
+        content: "Hello, Claude"
+      }],
+      model: "claude-3-5-sonnet-latest"
+    )
+rescue Anthropic::Errors::APIError => e
+  puts(e.status) # 400
+end
+```
+
+Error codes are as followed:
+
+| Cause            | Error Type                 |
+| ---------------- | -------------------------- |
+| HTTP 400         | `BadRequestError`          |
+| HTTP 401         | `AuthenticationError`      |
+| HTTP 403         | `PermissionDeniedError`    |
+| HTTP 404         | `NotFoundError`            |
+| HTTP 409         | `ConflictError`            |
+| HTTP 422         | `UnprocessableEntityError` |
+| HTTP 429         | `RateLimitError`           |
+| HTTP >= 500      | `InternalServerError`      |
+| Other HTTP error | `APIStatusError`           |
+| Timeout          | `APITimeoutError`          |
+| Network error    | `APIConnectionError`       |
+
+### Retries
+
+Certain errors will be automatically retried 2 times by default, with a short exponential backoff.
+
+Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict, 429 Rate Limit, >=500 Internal errors, and timeouts will all be retried by default.
+
+You can use the `max_retries` option to configure or disable this:
+
+```ruby
+# Configure the default for all requests:
+anthropic = Anthropic::Client.new(
+  max_retries: 0 # default is 2
+)
+
+# Or, configure per-request:
+anthropic.messages.create(
+  max_tokens: 1024,
+  messages: [{
+    role: "user",
+    content: "Hello, Claude"
+  }],
+  model: "claude-3-5-sonnet-latest",
+  request_options: {max_retries: 5}
+)
+```
+
+### Timeouts
+
+By default, requests will time out after 600 seconds.
+
+Timeouts are applied separately to the initial connection and the overall request time, so in some cases a request could wait 2\*timeout seconds before it fails.
+
+You can use the `timeout` option to configure or disable this:
+
+```ruby
+# Configure the default for all requests:
+anthropic = Anthropic::Client.new(
+  timeout: nil # default is 600
+)
+
+# Or, configure per-request:
+anthropic.messages.create(
+  max_tokens: 1024,
+  messages: [{
+    role: "user",
+    content: "Hello, Claude"
+  }],
+  model: "claude-3-5-sonnet-latest",
+  request_options: {timeout: 5}
+)
+```
+
+## LSP Support
+
+### Solargraph
+
+This library includes [Solargraph](https://solargraph.org) support for both auto completion and go to definition.
+
+```ruby
+gem "solargraph", group: :development
+```
+
+After Solargraph is installed, **you must populate its index** either via the provided editor command, or by running the following in your terminal:
+
+```sh
+bundle exec solargraph gems
+```
+
+Note: if you had installed the gem either using a `git:` or `github:` URL, or had vendored the gem using bundler, you will need to set up your [`.solargraph.yml`](https://solargraph.org/guides/configuration) to include the path to the gem's `lib` directory.
+
+```yaml
+include:
+  - 'vendor/bundle/ruby/*/gems/anthropic-sdk-beta-*/lib/**/*.rb'
+```
+
+Otherwise Solargraph will not be able to provide type information or auto-completion for any non-indexed libraries.
+
+### Sorbet
+
+This library is written with [Sorbet type definitions](https://sorbet.org/docs/rbi). However, there is no runtime dependency on the `sorbet-runtime`.
+
+What this means is that while you can use Sorbet to type check your code statically, and benefit from the [Sorbet Language Server](https://sorbet.org/docs/lsp) in your editor, there is no runtime type checking and execution overhead from Sorbet itself.
+
+Due to limitations with the Sorbet type system, where a method otherwise can take an instance of `Anthropic::BaseModel` class, you will need to use the `**` splat operator to pass the arguments:
+
+Please follow Sorbet's [setup guides](https://sorbet.org/docs/adopting) for best experience.
+
+```ruby
+params =
+  Anthropic::Models::MessageCreateParams.new(
+    max_tokens: 1024,
+    messages: [Anthropic::Models::MessageParam.new(role: :user, content: "hello")],
+    model: "claude-3-5-sonnet-latest"
+  )
+
+anthropic.messages.create(**params)
+```
+
+Note: **This library emits an intentional warning under the [`tapioca` toolchain](https://github.com/Shopify/tapioca)**. This is normal, and does not impact functionality.
+
+### Ruby LSP
+
+The Ruby LSP has [best effort support](https://shopify.github.io/ruby-lsp/#guessed-types) for inferring type information from Ruby code, and as such it may not always be able to provide accurate type information.
+
+
+## AWS Bedrock
+
+This library also provides support for the [Anthropic Bedrock API](https://aws.amazon.com/bedrock/claude/) if you install this library with the `aws-sdk-bedrockruntime` gem.
+
+You can then instantiate a separate `Anthropic::Bedrock::Client` class, and use AWS's standard guide for configuring credentials (see [the aws-sdk-ruby gem README](https://github.com/aws/aws-sdk-ruby?tab=readme-ov-file#configuration) or [AWS Documentation](https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/setup-config.html#credchain)). It has the same API as the base `Anthropic::Client` class.
+
+Note that the model ID required is different for Bedrock models, and, depending on the model you want to use, you will need to use either the AWS's model ID for Anthropic models -- which can be found in [AWS's Bedrock model catalog](https://docs.aws.amazon.com/bedrock/latest/userguide/models-supported.html) -- or an inference profile id (e.g. `us.anthropic.claude-3-5-haiku-20241022-v1:0` for Claude 3.5 Haiku).
+
+```ruby
+require "bundler/setup"
+require "anthropic"
+
+anthropic = Anthropic::Bedrock::Client.new
+
+message = anthropic.messages.create(
+  max_tokens: 1024,
+  messages: [
+    {
+      role: "user",
+      content: "Hello, Claude"
+    }
+  ],
+  model: "anthropic.claude-3-5-sonnet-20241022-v2:0"
+)
+
+puts message
+```
+
+For more examples see [`examples/bedrock`](examples/bedrock).
+
+## Google Vertex
+
+This library also provides support for the [Anthropic Vertex API](https://cloud.google.com/vertex-ai?hl=en) if you install this library with the `googleauth` gem.
+
+You can then import and instantiate a separate `Anthropic::Vertex::Client` class, and use Google's guide for configuring [Application Default Credentials](https://cloud.google.com/docs/authentication/provide-credentials-adc). It has the same API as the base `Anthropic::Client` class.
+
+```ruby
+require "bundler/setup"
+require "anthropic"
+
+anthropic = Anthropic::Vertex::Client.new(region: "us-east5", project_id: "my-project-id")
+
+message = anthropic.messages.create(
+  max_tokens: 1024,
+  messages: [
+    {
+      role: "user",
+      content: "Hello, Claude"
+    }
+  ],
+  model: "claude-3-7-sonnet@20250219"
+)
+
+puts message
+```
+
+For more examples see [`examples/vertex`](examples/vertex).
+
+## Advanced
+
+### Making custom/undocumented requests
+
+This library is typed for convenient access to the documented API.
+
+If you need to access undocumented endpoints, params, or response properties, the library can still be used.
+
+#### Undocumented request params
+
+If you want to explicitly send an extra param, you can do so with the `extra_query`, `extra_body`, and `extra_headers` under the `request_options:` parameter when making a requests as seen in examples above.
+
+#### Undocumented endpoints
+
+To make requests to undocumented endpoints, you can make requests using `client.request`. Options on the client will be respected (such as retries) when making this request.
+
+```ruby
+response =
+  client.request(
+    method: :post,
+    path: '/undocumented/endpoint',
+    query: {"dog": "woof"},
+    headers: {"useful-header": "interesting-value"},
+    body: {"he": "llo"},
+  )
+```
+
+### Concurrency & Connection Pooling
+
+The `Anthropic::Client` instances are thread-safe, and should be re-used across multiple threads. By default, each `Client` have their own HTTP connection pool, with a maximum number of connections equal to thread count.
+
+When the maximum number of connections has been checked out from the connection pool, the `Client` will wait for an in use connection to become available. The queue time for this mechanism is accounted for by the per-request timeout.
+
+Unless otherwise specified, other classes in the SDK do not have locks protecting their underlying data structure.
+
+Currently, `Anthropic::Client` instances are only fork-safe if there are no in-flight HTTP requests.
+
+## Versioning
+
+This package follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions. As the library is in initial development and has a major version of `0`, APIs may change at any time.
+
+This package considers improvements to the (non-runtime) `*.rbi` and `*.rbs` type definitions to be non-breaking changes.
+
+## Requirements
+
+Ruby 3.1.0 or higher.
+
+## Acknowledgements
+Thank you @alexrudall for giving feedback, donating the `anthropic` Ruby Gem name, and paving the way by building the first Anthropic Ruby SDK.

data/lib/anthropic/bedrock/client.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module Anthropic
+  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
+
+      # @!attribute [r] signer
+      #   @return [Aws::Sigv4::Signer]
+      #   @!visibility private
+
+      # 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
+
+      # @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, nil}, nil] :headers
+      #
+      #   @option req [Object, nil] :body
+      #
+      #   @option req [Symbol, nil] :unwrap
+      #
+      #   @option req [Class, nil] :page
+      #
+      #   @option req [Anthropic::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 [Hash{Symbol=>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
+        }
+        unless aws_region.nil?
+          client_options[:region] = aws_region
+        end
+
+        bedrock_client = Aws::BedrockRuntime::Client.new(client_options)
+        [bedrock_client.config.region, bedrock_client.config.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}
+          raise Anthropic::Error, "The Batch API is not supported in Bedrock yet"
+        in %r{v1/messages/count_tokens}
+          raise Anthropic::Error, "Token counting is not supported in Bedrock yet"
+        in %r{v1/models\?beta=true}
+          raise Anthropic::Error,
+                "Please instead use https://docs.anthropic.com/en/api/claude-on-amazon-bedrock#list-available-models to list available models on Bedrock."
+        else
+          # no-op
+        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