anthropic 0.4.1 → 1.1.0

data/lib/anthropic/models/completion_create_params.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    # @see Anthropic::Resources::Completions#create
+    #
+    # @see Anthropic::Resources::Completions#create_streaming
+    class CompletionCreateParams < Anthropic::Internal::Type::BaseModel
+      extend Anthropic::Internal::Type::RequestParameters::Converter
+      include Anthropic::Internal::Type::RequestParameters
+
+      # @!attribute max_tokens_to_sample
+      #   The maximum number of tokens to generate before stopping.
+      #
+      #   Note that our models may stop _before_ reaching this maximum. This parameter
+      #   only specifies the absolute maximum number of tokens to generate.
+      #
+      #   @return [Integer]
+      required :max_tokens_to_sample, Integer
+
+      # @!attribute model
+      #   The model that will complete your prompt.\n\nSee
+      #   [models](https://docs.anthropic.com/en/docs/models-overview) for additional
+      #   details and options.
+      #
+      #   @return [Symbol, String, Anthropic::Models::Model]
+      required :model, union: -> { Anthropic::Model }
+
+      # @!attribute prompt
+      #   The prompt that you want Claude to complete.
+      #
+      #   For proper response generation you will need to format your prompt using
+      #   alternating `\n\nHuman:` and `\n\nAssistant:` conversational turns. For example:
+      #
+      #   ```
+      #   "\n\nHuman: {userQuestion}\n\nAssistant:"
+      #   ```
+      #
+      #   See [prompt validation](https://docs.anthropic.com/en/api/prompt-validation) and
+      #   our guide to
+      #   [prompt design](https://docs.anthropic.com/en/docs/intro-to-prompting) for more
+      #   details.
+      #
+      #   @return [String]
+      required :prompt, String
+
+      # @!attribute metadata
+      #   An object describing metadata about the request.
+      #
+      #   @return [Anthropic::Models::Metadata, nil]
+      optional :metadata, -> { Anthropic::Metadata }
+
+      # @!attribute stop_sequences
+      #   Sequences that will cause the model to stop generating.
+      #
+      #   Our models stop on `"\n\nHuman:"`, and may include additional built-in stop
+      #   sequences in the future. By providing the stop_sequences parameter, you may
+      #   include additional strings that will cause the model to stop generating.
+      #
+      #   @return [Array<String>, nil]
+      optional :stop_sequences, Anthropic::Internal::Type::ArrayOf[String]
+
+      # @!attribute temperature
+      #   Amount of randomness injected into the response.
+      #
+      #   Defaults to `1.0`. Ranges from `0.0` to `1.0`. Use `temperature` closer to `0.0`
+      #   for analytical / multiple choice, and closer to `1.0` for creative and
+      #   generative tasks.
+      #
+      #   Note that even with `temperature` of `0.0`, the results will not be fully
+      #   deterministic.
+      #
+      #   @return [Float, nil]
+      optional :temperature, Float
+
+      # @!attribute top_k
+      #   Only sample from the top K options for each subsequent token.
+      #
+      #   Used to remove "long tail" low probability responses.
+      #   [Learn more technical details here](https://towardsdatascience.com/how-to-sample-from-language-models-682bceb97277).
+      #
+      #   Recommended for advanced use cases only. You usually only need to use
+      #   `temperature`.
+      #
+      #   @return [Integer, nil]
+      optional :top_k, Integer
+
+      # @!attribute top_p
+      #   Use nucleus sampling.
+      #
+      #   In nucleus sampling, we compute the cumulative distribution over all the options
+      #   for each subsequent token in decreasing probability order and cut it off once it
+      #   reaches a particular probability specified by `top_p`. You should either alter
+      #   `temperature` or `top_p`, but not both.
+      #
+      #   Recommended for advanced use cases only. You usually only need to use
+      #   `temperature`.
+      #
+      #   @return [Float, nil]
+      optional :top_p, Float
+
+      # @!attribute betas
+      #   Optional header to specify the beta version(s) you want to use.
+      #
+      #   @return [Array<String, Symbol, Anthropic::Models::AnthropicBeta>, nil]
+      optional :betas, -> { Anthropic::Internal::Type::ArrayOf[union: Anthropic::AnthropicBeta] }
+
+      # @!method initialize(max_tokens_to_sample:, model:, prompt:, metadata: nil, stop_sequences: nil, temperature: nil, top_k: nil, top_p: nil, betas: nil, request_options: {})
+      #   Some parameter documentations has been truncated, see
+      #   {Anthropic::Models::CompletionCreateParams} for more details.
+      #
+      #   @param max_tokens_to_sample [Integer] The maximum number of tokens to generate before stopping.
+      #
+      #   @param model [Symbol, String, Anthropic::Models::Model] The model that will complete your prompt.\n\nSee [models](https://docs.anthropic
+      #
+      #   @param prompt [String] The prompt that you want Claude to complete.
+      #
+      #   @param metadata [Anthropic::Models::Metadata] An object describing metadata about the request.
+      #
+      #   @param stop_sequences [Array<String>] Sequences that will cause the model to stop generating.
+      #
+      #   @param temperature [Float] Amount of randomness injected into the response.
+      #
+      #   @param top_k [Integer] Only sample from the top K options for each subsequent token.
+      #
+      #   @param top_p [Float] Use nucleus sampling.
+      #
+      #   @param betas [Array<String, Symbol, Anthropic::Models::AnthropicBeta>] Optional header to specify the beta version(s) you want to use.
+      #
+      #   @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}]
+    end
+  end
+end

data/lib/anthropic/models/content_block.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    module ContentBlock
+      extend Anthropic::Internal::Type::Union
+
+      discriminator :type
+
+      variant :text, -> { Anthropic::TextBlock }
+
+      variant :tool_use, -> { Anthropic::ToolUseBlock }
+
+      variant :server_tool_use, -> { Anthropic::ServerToolUseBlock }
+
+      variant :web_search_tool_result, -> { Anthropic::WebSearchToolResultBlock }
+
+      variant :thinking, -> { Anthropic::ThinkingBlock }
+
+      variant :redacted_thinking, -> { Anthropic::RedactedThinkingBlock }
+
+      # @!method self.variants
+      #   @return [Array(Anthropic::Models::TextBlock, Anthropic::Models::ToolUseBlock, Anthropic::Models::ServerToolUseBlock, Anthropic::Models::WebSearchToolResultBlock, Anthropic::Models::ThinkingBlock, Anthropic::Models::RedactedThinkingBlock)]
+    end
+  end
+end

data/lib/anthropic/models/content_block_param.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    # Regular text content.
+    module ContentBlockParam
+      extend Anthropic::Internal::Type::Union
+
+      discriminator :type
+
+      variant :server_tool_use, -> { Anthropic::ServerToolUseBlockParam }
+
+      variant :web_search_tool_result, -> { Anthropic::WebSearchToolResultBlockParam }
+
+      # Regular text content.
+      variant :text, -> { Anthropic::TextBlockParam }
+
+      # Image content specified directly as base64 data or as a reference via a URL.
+      variant :image, -> { Anthropic::ImageBlockParam }
+
+      # A block indicating a tool use by the model.
+      variant :tool_use, -> { Anthropic::ToolUseBlockParam }
+
+      # A block specifying the results of a tool use by the model.
+      variant :tool_result, -> { Anthropic::ToolResultBlockParam }
+
+      # Document content, either specified directly as base64 data, as text, or as a reference via a URL.
+      variant :document, -> { Anthropic::DocumentBlockParam }
+
+      # A block specifying internal thinking by the model.
+      variant :thinking, -> { Anthropic::ThinkingBlockParam }
+
+      # A block specifying internal, redacted thinking by the model.
+      variant :redacted_thinking, -> { Anthropic::RedactedThinkingBlockParam }
+
+      # @!method self.variants
+      #   @return [Array(Anthropic::Models::ServerToolUseBlockParam, Anthropic::Models::WebSearchToolResultBlockParam, Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam, Anthropic::Models::ToolUseBlockParam, Anthropic::Models::ToolResultBlockParam, Anthropic::Models::DocumentBlockParam, Anthropic::Models::ThinkingBlockParam, Anthropic::Models::RedactedThinkingBlockParam)]
+    end
+  end
+end

data/lib/anthropic/models/content_block_source.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ContentBlockSource < Anthropic::Internal::Type::BaseModel
+      # @!attribute content
+      #
+      #   @return [String, Array<Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam>]
+      required :content, union: -> { Anthropic::ContentBlockSource::Content }
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :content]
+      required :type, const: :content
+
+      # @!method initialize(content:, type: :content)
+      #   @param content [String, Array<Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam>]
+      #   @param type [Symbol, :content]
+
+      # @see Anthropic::Models::ContentBlockSource#content
+      module Content
+        extend Anthropic::Internal::Type::Union
+
+        variant String
+
+        variant -> { Anthropic::Models::ContentBlockSource::Content::ContentBlockSourceContentArray }
+
+        # @!method self.variants
+        #   @return [Array(String, Array<Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam>)]
+
+        # @type [Anthropic::Internal::Type::Converter]
+        ContentBlockSourceContentArray =
+          Anthropic::Internal::Type::ArrayOf[union: -> { Anthropic::ContentBlockSourceContent }]
+      end
+    end
+  end
+end

data/lib/anthropic/models/content_block_source_content.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    module ContentBlockSourceContent
+      extend Anthropic::Internal::Type::Union
+
+      discriminator :type
+
+      variant :text, -> { Anthropic::TextBlockParam }
+
+      variant :image, -> { Anthropic::ImageBlockParam }
+
+      # @!method self.variants
+      #   @return [Array(Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam)]
+    end
+  end
+end

data/lib/anthropic/models/document_block_param.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class DocumentBlockParam < Anthropic::Internal::Type::BaseModel
+      # @!attribute source
+      #
+      #   @return [Anthropic::Models::Base64PDFSource, Anthropic::Models::PlainTextSource, Anthropic::Models::ContentBlockSource, Anthropic::Models::URLPDFSource]
+      required :source, union: -> { Anthropic::DocumentBlockParam::Source }
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :document]
+      required :type, const: :document
+
+      # @!attribute cache_control
+      #   Create a cache control breakpoint at this content block.
+      #
+      #   @return [Anthropic::Models::CacheControlEphemeral, nil]
+      optional :cache_control, -> { Anthropic::CacheControlEphemeral }, nil?: true
+
+      # @!attribute citations
+      #
+      #   @return [Anthropic::Models::CitationsConfigParam, nil]
+      optional :citations, -> { Anthropic::CitationsConfigParam }
+
+      # @!attribute context
+      #
+      #   @return [String, nil]
+      optional :context, String, nil?: true
+
+      # @!attribute title
+      #
+      #   @return [String, nil]
+      optional :title, String, nil?: true
+
+      # @!method initialize(source:, cache_control: nil, citations: nil, context: nil, title: nil, type: :document)
+      #   @param source [Anthropic::Models::Base64PDFSource, Anthropic::Models::PlainTextSource, Anthropic::Models::ContentBlockSource, Anthropic::Models::URLPDFSource]
+      #
+      #   @param cache_control [Anthropic::Models::CacheControlEphemeral, nil] Create a cache control breakpoint at this content block.
+      #
+      #   @param citations [Anthropic::Models::CitationsConfigParam]
+      #
+      #   @param context [String, nil]
+      #
+      #   @param title [String, nil]
+      #
+      #   @param type [Symbol, :document]
+
+      # @see Anthropic::Models::DocumentBlockParam#source
+      module Source
+        extend Anthropic::Internal::Type::Union
+
+        discriminator :type
+
+        variant :base64, -> { Anthropic::Base64PDFSource }
+
+        variant :text, -> { Anthropic::PlainTextSource }
+
+        variant :content, -> { Anthropic::ContentBlockSource }
+
+        variant :url, -> { Anthropic::URLPDFSource }
+
+        # @!method self.variants
+        #   @return [Array(Anthropic::Models::Base64PDFSource, Anthropic::Models::PlainTextSource, Anthropic::Models::ContentBlockSource, Anthropic::Models::URLPDFSource)]
+      end
+    end
+  end
+end

data/lib/anthropic/models/error_object.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    module ErrorObject
+      extend Anthropic::Internal::Type::Union
+
+      discriminator :type
+
+      variant :invalid_request_error, -> { Anthropic::InvalidRequestError }
+
+      variant :authentication_error, -> { Anthropic::AuthenticationError }
+
+      variant :billing_error, -> { Anthropic::BillingError }
+
+      variant :permission_error, -> { Anthropic::PermissionError }
+
+      variant :not_found_error, -> { Anthropic::NotFoundError }
+
+      variant :rate_limit_error, -> { Anthropic::RateLimitError }
+
+      variant :timeout_error, -> { Anthropic::GatewayTimeoutError }
+
+      variant :api_error, -> { Anthropic::APIErrorObject }
+
+      variant :overloaded_error, -> { Anthropic::OverloadedError }
+
+      # @!method self.variants
+      #   @return [Array(Anthropic::Models::InvalidRequestError, Anthropic::Models::AuthenticationError, Anthropic::Models::BillingError, Anthropic::Models::PermissionError, Anthropic::Models::NotFoundError, Anthropic::Models::RateLimitError, Anthropic::Models::GatewayTimeoutError, Anthropic::Models::APIErrorObject, Anthropic::Models::OverloadedError)]
+    end
+  end
+end

data/lib/anthropic/models/error_response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ErrorResponse < Anthropic::Internal::Type::BaseModel
+      # @!attribute error
+      #
+      #   @return [Anthropic::Models::InvalidRequestError, Anthropic::Models::AuthenticationError, Anthropic::Models::BillingError, Anthropic::Models::PermissionError, Anthropic::Models::NotFoundError, Anthropic::Models::RateLimitError, Anthropic::Models::GatewayTimeoutError, Anthropic::Models::APIErrorObject, Anthropic::Models::OverloadedError]
+      required :error, union: -> { Anthropic::ErrorObject }
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :error]
+      required :type, const: :error
+
+      # @!method initialize(error:, type: :error)
+      #   @param error [Anthropic::Models::InvalidRequestError, Anthropic::Models::AuthenticationError, Anthropic::Models::BillingError, Anthropic::Models::PermissionError, Anthropic::Models::NotFoundError, Anthropic::Models::RateLimitError, Anthropic::Models::GatewayTimeoutError, Anthropic::Models::APIErrorObject, Anthropic::Models::OverloadedError]
+      #   @param type [Symbol, :error]
+    end
+  end
+end

data/lib/anthropic/models/gateway_timeout_error.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class GatewayTimeoutError < Anthropic::Internal::Type::BaseModel
+      # @!attribute message
+      #
+      #   @return [String]
+      required :message, String
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :timeout_error]
+      required :type, const: :timeout_error
+
+      # @!method initialize(message:, type: :timeout_error)
+      #   @param message [String]
+      #   @param type [Symbol, :timeout_error]
+    end
+  end
+end

data/lib/anthropic/models/image_block_param.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ImageBlockParam < Anthropic::Internal::Type::BaseModel
+      # @!attribute source
+      #
+      #   @return [Anthropic::Models::Base64ImageSource, Anthropic::Models::URLImageSource]
+      required :source, union: -> { Anthropic::ImageBlockParam::Source }
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :image]
+      required :type, const: :image
+
+      # @!attribute cache_control
+      #   Create a cache control breakpoint at this content block.
+      #
+      #   @return [Anthropic::Models::CacheControlEphemeral, nil]
+      optional :cache_control, -> { Anthropic::CacheControlEphemeral }, nil?: true
+
+      # @!method initialize(source:, cache_control: nil, type: :image)
+      #   @param source [Anthropic::Models::Base64ImageSource, Anthropic::Models::URLImageSource]
+      #
+      #   @param cache_control [Anthropic::Models::CacheControlEphemeral, nil] Create a cache control breakpoint at this content block.
+      #
+      #   @param type [Symbol, :image]
+
+      # @see Anthropic::Models::ImageBlockParam#source
+      module Source
+        extend Anthropic::Internal::Type::Union
+
+        discriminator :type
+
+        variant :base64, -> { Anthropic::Base64ImageSource }
+
+        variant :url, -> { Anthropic::URLImageSource }
+
+        # @!method self.variants
+        #   @return [Array(Anthropic::Models::Base64ImageSource, Anthropic::Models::URLImageSource)]
+      end
+    end
+  end
+end

data/lib/anthropic/models/input_json_delta.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class InputJSONDelta < Anthropic::Internal::Type::BaseModel
+      # @!attribute partial_json
+      #
+      #   @return [String]
+      required :partial_json, String
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :input_json_delta]
+      required :type, const: :input_json_delta
+
+      # @!method initialize(partial_json:, type: :input_json_delta)
+      #   @param partial_json [String]
+      #   @param type [Symbol, :input_json_delta]
+    end
+  end
+end

data/lib/anthropic/models/invalid_request_error.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class InvalidRequestError < Anthropic::Internal::Type::BaseModel
+      # @!attribute message
+      #
+      #   @return [String]
+      required :message, String
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :invalid_request_error]
+      required :type, const: :invalid_request_error
+
+      # @!method initialize(message:, type: :invalid_request_error)
+      #   @param message [String]
+      #   @param type [Symbol, :invalid_request_error]
+    end
+  end
+end

data/lib/anthropic/models/message.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    # @see Anthropic::Resources::Messages#create
+    #
+    # @see Anthropic::Resources::Messages#stream_raw
+    class Message < Anthropic::Internal::Type::BaseModel
+      # @!attribute id
+      #   Unique object identifier.
+      #
+      #   The format and length of IDs may change over time.
+      #
+      #   @return [String]
+      required :id, String
+
+      # @!attribute content
+      #   Content generated by the model.
+      #
+      #   This is an array of content blocks, each of which has a `type` that determines
+      #   its shape.
+      #
+      #   Example:
+      #
+      #   ```json
+      #   [{ "type": "text", "text": "Hi, I'm Claude." }]
+      #   ```
+      #
+      #   If the request input `messages` ended with an `assistant` turn, then the
+      #   response `content` will continue directly from that last turn. You can use this
+      #   to constrain the model's output.
+      #
+      #   For example, if the input `messages` were:
+      #
+      #   ```json
+      #   [
+      #     {
+      #       "role": "user",
+      #       "content": "What's the Greek name for Sun? (A) Sol (B) Helios (C) Sun"
+      #     },
+      #     { "role": "assistant", "content": "The best answer is (" }
+      #   ]
+      #   ```
+      #
+      #   Then the response `content` might be:
+      #
+      #   ```json
+      #   [{ "type": "text", "text": "B)" }]
+      #   ```
+      #
+      #   @return [Array<Anthropic::Models::TextBlock, Anthropic::Models::ToolUseBlock, Anthropic::Models::ServerToolUseBlock, Anthropic::Models::WebSearchToolResultBlock, Anthropic::Models::ThinkingBlock, Anthropic::Models::RedactedThinkingBlock>]
+      required :content, -> { Anthropic::Internal::Type::ArrayOf[union: Anthropic::ContentBlock] }
+
+      # @!attribute model
+      #   The model that will complete your prompt.\n\nSee
+      #   [models](https://docs.anthropic.com/en/docs/models-overview) for additional
+      #   details and options.
+      #
+      #   @return [Symbol, String, Anthropic::Models::Model]
+      required :model, union: -> { Anthropic::Model }
+
+      # @!attribute role
+      #   Conversational role of the generated message.
+      #
+      #   This will always be `"assistant"`.
+      #
+      #   @return [Symbol, :assistant]
+      required :role, const: :assistant
+
+      # @!attribute stop_reason
+      #   The reason that we stopped.
+      #
+      #   This may be one the following values:
+      #
+      #   - `"end_turn"`: the model reached a natural stopping point
+      #   - `"max_tokens"`: we exceeded the requested `max_tokens` or the model's maximum
+      #   - `"stop_sequence"`: one of your provided custom `stop_sequences` was generated
+      #   - `"tool_use"`: the model invoked one or more tools
+      #
+      #   In non-streaming mode this value is always non-null. In streaming mode, it is
+      #   null in the `message_start` event and non-null otherwise.
+      #
+      #   @return [Symbol, Anthropic::Models::StopReason, nil]
+      required :stop_reason, enum: -> { Anthropic::StopReason }, nil?: true
+
+      # @!attribute stop_sequence
+      #   Which custom stop sequence was generated, if any.
+      #
+      #   This value will be a non-null string if one of your custom stop sequences was
+      #   generated.
+      #
+      #   @return [String, nil]
+      required :stop_sequence, String, nil?: true
+
+      # @!attribute type
+      #   Object type.
+      #
+      #   For Messages, this is always `"message"`.
+      #
+      #   @return [Symbol, :message]
+      required :type, const: :message
+
+      # @!attribute usage
+      #   Billing and rate-limit usage.
+      #
+      #   Anthropic's API bills and rate-limits by token counts, as tokens represent the
+      #   underlying cost to our systems.
+      #
+      #   Under the hood, the API transforms requests into a format suitable for the
+      #   model. The model's output then goes through a parsing stage before becoming an
+      #   API response. As a result, the token counts in `usage` will not match one-to-one
+      #   with the exact visible content of an API request or response.
+      #
+      #   For example, `output_tokens` will be non-zero, even for an empty string response
+      #   from Claude.
+      #
+      #   Total input tokens in a request is the summation of `input_tokens`,
+      #   `cache_creation_input_tokens`, and `cache_read_input_tokens`.
+      #
+      #   @return [Anthropic::Models::Usage]
+      required :usage, -> { Anthropic::Usage }
+
+      # @!method initialize(id:, content:, model:, stop_reason:, stop_sequence:, usage:, role: :assistant, type: :message)
+      #   Some parameter documentations has been truncated, see
+      #   {Anthropic::Models::Message} for more details.
+      #
+      #   @param id [String] Unique object identifier.
+      #
+      #   @param content [Array<Anthropic::Models::TextBlock, Anthropic::Models::ToolUseBlock, Anthropic::Models::ServerToolUseBlock, Anthropic::Models::WebSearchToolResultBlock, Anthropic::Models::ThinkingBlock, Anthropic::Models::RedactedThinkingBlock>] Content generated by the model.
+      #
+      #   @param model [Symbol, String, Anthropic::Models::Model] The model that will complete your prompt.\n\nSee [models](https://docs.anthropic
+      #
+      #   @param stop_reason [Symbol, Anthropic::Models::StopReason, nil] The reason that we stopped.
+      #
+      #   @param stop_sequence [String, nil] Which custom stop sequence was generated, if any.
+      #
+      #   @param usage [Anthropic::Models::Usage] Billing and rate-limit usage.
+      #
+      #   @param role [Symbol, :assistant] Conversational role of the generated message.
+      #
+      #   @param type [Symbol, :message] Object type.
+    end
+  end
+end