anthropic 0.0.0 → 0.1.0.pre.beta.9

data/rbi/anthropic/models.rbi

@@ -0,0 +1,229 @@
+# typed: strong
+
+module Anthropic
+  AnthropicBeta = Anthropic::Models::AnthropicBeta
+
+  APIErrorObject = Anthropic::Models::APIErrorObject
+
+  AuthenticationError = Anthropic::Models::AuthenticationError
+
+  Base64ImageSource = Anthropic::Models::Base64ImageSource
+
+  Base64PDFSource = Anthropic::Models::Base64PDFSource
+
+  Beta = Anthropic::Models::Beta
+
+  BetaAPIError = Anthropic::Models::BetaAPIError
+
+  BetaAuthenticationError = Anthropic::Models::BetaAuthenticationError
+
+  BetaBillingError = Anthropic::Models::BetaBillingError
+
+  BetaError = Anthropic::Models::BetaError
+
+  BetaErrorResponse = Anthropic::Models::BetaErrorResponse
+
+  BetaGatewayTimeoutError = Anthropic::Models::BetaGatewayTimeoutError
+
+  BetaInvalidRequestError = Anthropic::Models::BetaInvalidRequestError
+
+  BetaNotFoundError = Anthropic::Models::BetaNotFoundError
+
+  BetaOverloadedError = Anthropic::Models::BetaOverloadedError
+
+  BetaPermissionError = Anthropic::Models::BetaPermissionError
+
+  BetaRateLimitError = Anthropic::Models::BetaRateLimitError
+
+  BillingError = Anthropic::Models::BillingError
+
+  CacheControlEphemeral = Anthropic::Models::CacheControlEphemeral
+
+  CitationCharLocation = Anthropic::Models::CitationCharLocation
+
+  CitationCharLocationParam = Anthropic::Models::CitationCharLocationParam
+
+  CitationContentBlockLocation = Anthropic::Models::CitationContentBlockLocation
+
+  CitationContentBlockLocationParam =
+    Anthropic::Models::CitationContentBlockLocationParam
+
+  CitationPageLocation = Anthropic::Models::CitationPageLocation
+
+  CitationPageLocationParam = Anthropic::Models::CitationPageLocationParam
+
+  CitationsConfigParam = Anthropic::Models::CitationsConfigParam
+
+  CitationsDelta = Anthropic::Models::CitationsDelta
+
+  CitationsWebSearchResultLocation =
+    Anthropic::Models::CitationsWebSearchResultLocation
+
+  CitationWebSearchResultLocationParam =
+    Anthropic::Models::CitationWebSearchResultLocationParam
+
+  Completion = Anthropic::Models::Completion
+
+  CompletionCreateParams = Anthropic::Models::CompletionCreateParams
+
+  ContentBlock = Anthropic::Models::ContentBlock
+
+  ContentBlockParam = Anthropic::Models::ContentBlockParam
+
+  ContentBlockSource = Anthropic::Models::ContentBlockSource
+
+  ContentBlockSourceContent = Anthropic::Models::ContentBlockSourceContent
+
+  DocumentBlockParam = Anthropic::Models::DocumentBlockParam
+
+  ErrorObject = Anthropic::Models::ErrorObject
+
+  ErrorResponse = Anthropic::Models::ErrorResponse
+
+  GatewayTimeoutError = Anthropic::Models::GatewayTimeoutError
+
+  ImageBlockParam = Anthropic::Models::ImageBlockParam
+
+  InputJSONDelta = Anthropic::Models::InputJSONDelta
+
+  InvalidRequestError = Anthropic::Models::InvalidRequestError
+
+  Message = Anthropic::Models::Message
+
+  MessageCountTokensParams = Anthropic::Models::MessageCountTokensParams
+
+  MessageCountTokensTool = Anthropic::Models::MessageCountTokensTool
+
+  MessageCreateParams = Anthropic::Models::MessageCreateParams
+
+  MessageDeltaUsage = Anthropic::Models::MessageDeltaUsage
+
+  MessageParam = Anthropic::Models::MessageParam
+
+  Messages = Anthropic::Models::Messages
+
+  MessageTokensCount = Anthropic::Models::MessageTokensCount
+
+  Metadata = Anthropic::Models::Metadata
+
+  Model = Anthropic::Models::Model
+
+  ModelInfo = Anthropic::Models::ModelInfo
+
+  ModelListParams = Anthropic::Models::ModelListParams
+
+  ModelRetrieveParams = Anthropic::Models::ModelRetrieveParams
+
+  NotFoundError = Anthropic::Models::NotFoundError
+
+  OverloadedError = Anthropic::Models::OverloadedError
+
+  PermissionError = Anthropic::Models::PermissionError
+
+  PlainTextSource = Anthropic::Models::PlainTextSource
+
+  RateLimitError = Anthropic::Models::RateLimitError
+
+  RawContentBlockDelta = Anthropic::Models::RawContentBlockDelta
+
+  RawContentBlockDeltaEvent = Anthropic::Models::RawContentBlockDeltaEvent
+
+  RawContentBlockStartEvent = Anthropic::Models::RawContentBlockStartEvent
+
+  RawContentBlockStopEvent = Anthropic::Models::RawContentBlockStopEvent
+
+  RawMessageDeltaEvent = Anthropic::Models::RawMessageDeltaEvent
+
+  RawMessageStartEvent = Anthropic::Models::RawMessageStartEvent
+
+  RawMessageStopEvent = Anthropic::Models::RawMessageStopEvent
+
+  RawMessageStreamEvent = Anthropic::Models::RawMessageStreamEvent
+
+  RedactedThinkingBlock = Anthropic::Models::RedactedThinkingBlock
+
+  RedactedThinkingBlockParam = Anthropic::Models::RedactedThinkingBlockParam
+
+  ServerToolUsage = Anthropic::Models::ServerToolUsage
+
+  ServerToolUseBlock = Anthropic::Models::ServerToolUseBlock
+
+  ServerToolUseBlockParam = Anthropic::Models::ServerToolUseBlockParam
+
+  SignatureDelta = Anthropic::Models::SignatureDelta
+
+  StopReason = Anthropic::Models::StopReason
+
+  TextBlock = Anthropic::Models::TextBlock
+
+  TextBlockParam = Anthropic::Models::TextBlockParam
+
+  TextCitation = Anthropic::Models::TextCitation
+
+  TextCitationParam = Anthropic::Models::TextCitationParam
+
+  TextDelta = Anthropic::Models::TextDelta
+
+  ThinkingBlock = Anthropic::Models::ThinkingBlock
+
+  ThinkingBlockParam = Anthropic::Models::ThinkingBlockParam
+
+  ThinkingConfigDisabled = Anthropic::Models::ThinkingConfigDisabled
+
+  ThinkingConfigEnabled = Anthropic::Models::ThinkingConfigEnabled
+
+  ThinkingConfigParam = Anthropic::Models::ThinkingConfigParam
+
+  ThinkingDelta = Anthropic::Models::ThinkingDelta
+
+  Tool = Anthropic::Models::Tool
+
+  ToolBash20250124 = Anthropic::Models::ToolBash20250124
+
+  ToolChoice = Anthropic::Models::ToolChoice
+
+  ToolChoiceAny = Anthropic::Models::ToolChoiceAny
+
+  ToolChoiceAuto = Anthropic::Models::ToolChoiceAuto
+
+  ToolChoiceNone = Anthropic::Models::ToolChoiceNone
+
+  ToolChoiceTool = Anthropic::Models::ToolChoiceTool
+
+  ToolResultBlockParam = Anthropic::Models::ToolResultBlockParam
+
+  ToolTextEditor20250124 = Anthropic::Models::ToolTextEditor20250124
+
+  ToolUnion = Anthropic::Models::ToolUnion
+
+  ToolUseBlock = Anthropic::Models::ToolUseBlock
+
+  ToolUseBlockParam = Anthropic::Models::ToolUseBlockParam
+
+  URLImageSource = Anthropic::Models::URLImageSource
+
+  URLPDFSource = Anthropic::Models::URLPDFSource
+
+  Usage = Anthropic::Models::Usage
+
+  WebSearchResultBlock = Anthropic::Models::WebSearchResultBlock
+
+  WebSearchResultBlockParam = Anthropic::Models::WebSearchResultBlockParam
+
+  WebSearchTool20250305 = Anthropic::Models::WebSearchTool20250305
+
+  WebSearchToolRequestError = Anthropic::Models::WebSearchToolRequestError
+
+  WebSearchToolResultBlock = Anthropic::Models::WebSearchToolResultBlock
+
+  WebSearchToolResultBlockContent =
+    Anthropic::Models::WebSearchToolResultBlockContent
+
+  WebSearchToolResultBlockParam =
+    Anthropic::Models::WebSearchToolResultBlockParam
+
+  WebSearchToolResultBlockParamContent =
+    Anthropic::Models::WebSearchToolResultBlockParamContent
+
+  WebSearchToolResultError = Anthropic::Models::WebSearchToolResultError
+end

data/rbi/anthropic/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Anthropic
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Anthropic::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(Anthropic::RequestOptions, Anthropic::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: Anthropic::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: Anthropic::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/anthropic/resources/beta/messages/batches.rbi

@@ -0,0 +1,186 @@
+# typed: strong
+
+module Anthropic
+  module Resources
+    class Beta
+      class Messages
+        class Batches
+          # Send a batch of Message creation requests.
+          #
+          # The Message Batches API can be used to process multiple Messages API requests at
+          # once. Once a Message Batch is created, it begins processing immediately. Batches
+          # can take up to 24 hours to complete.
+          #
+          # Learn more about the Message Batches API in our
+          # [user guide](/en/docs/build-with-claude/batch-processing)
+          sig do
+            params(
+              requests:
+                T::Array[
+                  Anthropic::Beta::Messages::BatchCreateParams::Request::OrHash
+                ],
+              betas:
+                T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)],
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(Anthropic::Beta::Messages::BetaMessageBatch)
+          end
+          def create(
+            # Body param: List of requests for prompt completion. Each is an individual
+            # request to create a Message.
+            requests:,
+            # Header param: Optional header to specify the beta version(s) you want to use.
+            betas: nil,
+            request_options: {}
+          )
+          end
+
+          # This endpoint is idempotent and can be used to poll for Message Batch
+          # completion. To access the results of a Message Batch, make a request to the
+          # `results_url` field in the response.
+          #
+          # Learn more about the Message Batches API in our
+          # [user guide](/en/docs/build-with-claude/batch-processing)
+          sig do
+            params(
+              message_batch_id: String,
+              betas:
+                T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)],
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(Anthropic::Beta::Messages::BetaMessageBatch)
+          end
+          def retrieve(
+            # ID of the Message Batch.
+            message_batch_id,
+            # Optional header to specify the beta version(s) you want to use.
+            betas: nil,
+            request_options: {}
+          )
+          end
+
+          # List all Message Batches within a Workspace. Most recently created batches are
+          # returned first.
+          #
+          # Learn more about the Message Batches API in our
+          # [user guide](/en/docs/build-with-claude/batch-processing)
+          sig do
+            params(
+              after_id: String,
+              before_id: String,
+              limit: Integer,
+              betas:
+                T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)],
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Internal::Page[
+                Anthropic::Beta::Messages::BetaMessageBatch
+              ]
+            )
+          end
+          def list(
+            # Query param: ID of the object to use as a cursor for pagination. When provided,
+            # returns the page of results immediately after this object.
+            after_id: nil,
+            # Query param: ID of the object to use as a cursor for pagination. When provided,
+            # returns the page of results immediately before this object.
+            before_id: nil,
+            # Query param: Number of items to return per page.
+            #
+            # Defaults to `20`. Ranges from `1` to `1000`.
+            limit: nil,
+            # Header param: Optional header to specify the beta version(s) you want to use.
+            betas: nil,
+            request_options: {}
+          )
+          end
+
+          # Delete a Message Batch.
+          #
+          # Message Batches can only be deleted once they've finished processing. If you'd
+          # like to delete an in-progress batch, you must first cancel it.
+          #
+          # Learn more about the Message Batches API in our
+          # [user guide](/en/docs/build-with-claude/batch-processing)
+          sig do
+            params(
+              message_batch_id: String,
+              betas:
+                T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)],
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(Anthropic::Beta::Messages::BetaDeletedMessageBatch)
+          end
+          def delete(
+            # ID of the Message Batch.
+            message_batch_id,
+            # Optional header to specify the beta version(s) you want to use.
+            betas: nil,
+            request_options: {}
+          )
+          end
+
+          # Batches may be canceled any time before processing ends. Once cancellation is
+          # initiated, the batch enters a `canceling` state, at which time the system may
+          # complete any in-progress, non-interruptible requests before finalizing
+          # cancellation.
+          #
+          # The number of canceled requests is specified in `request_counts`. To determine
+          # which requests were canceled, check the individual results within the batch.
+          # Note that cancellation may not result in any canceled requests if they were
+          # non-interruptible.
+          #
+          # Learn more about the Message Batches API in our
+          # [user guide](/en/docs/build-with-claude/batch-processing)
+          sig do
+            params(
+              message_batch_id: String,
+              betas:
+                T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)],
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(Anthropic::Beta::Messages::BetaMessageBatch)
+          end
+          def cancel(
+            # ID of the Message Batch.
+            message_batch_id,
+            # Optional header to specify the beta version(s) you want to use.
+            betas: nil,
+            request_options: {}
+          )
+          end
+
+          # Streams the results of a Message Batch as a `.jsonl` file.
+          #
+          # Each line in the file is a JSON object containing the result of a single request
+          # in the Message Batch. Results are not guaranteed to be in the same order as
+          # requests. Use the `custom_id` field to match results to requests.
+          #
+          # Learn more about the Message Batches API in our
+          # [user guide](/en/docs/build-with-claude/batch-processing)
+          sig do
+            params(
+              message_batch_id: String,
+              betas:
+                T::Array[T.any(String, Anthropic::AnthropicBeta::OrSymbol)],
+              request_options: Anthropic::RequestOptions::OrHash
+            ).returns(
+              Anthropic::Internal::JsonLStream[
+                Anthropic::Beta::Messages::BetaMessageBatchIndividualResponse
+              ]
+            )
+          end
+          def results_streaming(
+            # ID of the Message Batch.
+            message_batch_id,
+            # Optional header to specify the beta version(s) you want to use.
+            betas: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: Anthropic::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end