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

data/lib/anthropic/resources/completions.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Resources
+    class Completions
+      # See {Anthropic::Resources::Completions#create_streaming} for streaming
+      # counterpart.
+      #
+      # [Legacy] Create a Text Completion.
+      #
+      # The Text Completions API is a legacy API. We recommend using the
+      # [Messages API](https://docs.anthropic.com/en/api/messages) going forward.
+      #
+      # Future models and features will not be compatible with Text Completions. See our
+      # [migration guide](https://docs.anthropic.com/en/api/migrating-from-text-completions-to-messages)
+      # for guidance in migrating from Text Completions to Messages.
+      #
+      # @overload create(max_tokens_to_sample:, model:, prompt:, metadata: nil, stop_sequences: nil, temperature: nil, top_k: nil, top_p: nil, request_options: {})
+      #
+      # @param max_tokens_to_sample [Integer]
+      # @param model [Symbol, String, Anthropic::Models::Model]
+      # @param prompt [String]
+      # @param metadata [Anthropic::Models::Metadata]
+      # @param stop_sequences [Array<String>]
+      # @param temperature [Float]
+      # @param top_k [Integer]
+      # @param top_p [Float]
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Models::Completion]
+      #
+      # @see Anthropic::Models::CompletionCreateParams
+      def create(params)
+        parsed, options = Anthropic::Models::CompletionCreateParams.dump_request(params)
+        if parsed[:stream]
+          message = "Please use `#create_streaming` for the streaming use case."
+          raise ArgumentError.new(message)
+        end
+        @client.request(
+          method: :post,
+          path: "v1/complete",
+          body: parsed,
+          model: Anthropic::Models::Completion,
+          options: options
+        )
+      end
+
+      # See {Anthropic::Resources::Completions#create} for non-streaming counterpart.
+      #
+      # [Legacy] Create a Text Completion.
+      #
+      # The Text Completions API is a legacy API. We recommend using the
+      # [Messages API](https://docs.anthropic.com/en/api/messages) going forward.
+      #
+      # Future models and features will not be compatible with Text Completions. See our
+      # [migration guide](https://docs.anthropic.com/en/api/migrating-from-text-completions-to-messages)
+      # for guidance in migrating from Text Completions to Messages.
+      #
+      # @overload create_streaming(max_tokens_to_sample:, model:, prompt:, metadata: nil, stop_sequences: nil, temperature: nil, top_k: nil, top_p: nil, request_options: {})
+      #
+      # @param max_tokens_to_sample [Integer]
+      # @param model [Symbol, String, Anthropic::Models::Model]
+      # @param prompt [String]
+      # @param metadata [Anthropic::Models::Metadata]
+      # @param stop_sequences [Array<String>]
+      # @param temperature [Float]
+      # @param top_k [Integer]
+      # @param top_p [Float]
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Internal::Stream<Anthropic::Models::Completion>]
+      #
+      # @see Anthropic::Models::CompletionCreateParams
+      def create_streaming(params)
+        parsed, options = Anthropic::Models::CompletionCreateParams.dump_request(params)
+        unless parsed.fetch(:stream, true)
+          message = "Please use `#create` for the non-streaming use case."
+          raise ArgumentError.new(message)
+        end
+        parsed.store(:stream, true)
+        @client.request(
+          method: :post,
+          path: "v1/complete",
+          headers: {"accept" => "text/event-stream"},
+          body: parsed,
+          stream: Anthropic::Internal::Stream,
+          model: Anthropic::Models::Completion,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Anthropic::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/anthropic/resources/messages/batches.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Resources
+    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)
+        #
+        # @overload create(requests:, request_options: {})
+        #
+        # @param requests [Array<Anthropic::Models::Messages::BatchCreateParams::Request>]
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Models::Messages::MessageBatch]
+        #
+        # @see Anthropic::Models::Messages::BatchCreateParams
+        def create(params)
+          parsed, options = Anthropic::Models::Messages::BatchCreateParams.dump_request(params)
+          @client.request(
+            method: :post,
+            path: "v1/messages/batches",
+            body: parsed,
+            model: Anthropic::Models::Messages::MessageBatch,
+            options: 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)
+        #
+        # @overload retrieve(message_batch_id, request_options: {})
+        #
+        # @param message_batch_id [String]
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Models::Messages::MessageBatch]
+        #
+        # @see Anthropic::Models::Messages::BatchRetrieveParams
+        def retrieve(message_batch_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["v1/messages/batches/%1$s", message_batch_id],
+            model: Anthropic::Models::Messages::MessageBatch,
+            options: params[: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)
+        #
+        # @overload list(after_id: nil, before_id: nil, limit: nil, request_options: {})
+        #
+        # @param after_id [String]
+        # @param before_id [String]
+        # @param limit [Integer]
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Internal::Page<Anthropic::Models::Messages::MessageBatch>]
+        #
+        # @see Anthropic::Models::Messages::BatchListParams
+        def list(params = {})
+          parsed, options = Anthropic::Models::Messages::BatchListParams.dump_request(params)
+          @client.request(
+            method: :get,
+            path: "v1/messages/batches",
+            query: parsed,
+            page: Anthropic::Internal::Page,
+            model: Anthropic::Models::Messages::MessageBatch,
+            options: 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)
+        #
+        # @overload delete(message_batch_id, request_options: {})
+        #
+        # @param message_batch_id [String]
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Models::Messages::DeletedMessageBatch]
+        #
+        # @see Anthropic::Models::Messages::BatchDeleteParams
+        def delete(message_batch_id, params = {})
+          @client.request(
+            method: :delete,
+            path: ["v1/messages/batches/%1$s", message_batch_id],
+            model: Anthropic::Models::Messages::DeletedMessageBatch,
+            options: params[: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)
+        #
+        # @overload cancel(message_batch_id, request_options: {})
+        #
+        # @param message_batch_id [String]
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Models::Messages::MessageBatch]
+        #
+        # @see Anthropic::Models::Messages::BatchCancelParams
+        def cancel(message_batch_id, params = {})
+          @client.request(
+            method: :post,
+            path: ["v1/messages/batches/%1$s/cancel", message_batch_id],
+            model: Anthropic::Models::Messages::MessageBatch,
+            options: params[: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)
+        #
+        # @overload results_streaming(message_batch_id, request_options: {})
+        #
+        # @param message_batch_id [String]
+        # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @return [Anthropic::Internal::JsonLStream<Anthropic::Models::Messages::MessageBatchIndividualResponse>]
+        #
+        # @see Anthropic::Models::Messages::BatchResultsParams
+        def results_streaming(message_batch_id, params = {})
+          @client.request(
+            method: :get,
+            path: ["v1/messages/batches/%1$s/results", message_batch_id],
+            headers: {"accept" => "application/x-jsonl"},
+            stream: Anthropic::Internal::JsonLStream,
+            model: Anthropic::Models::Messages::MessageBatchIndividualResponse,
+            options: params[:request_options]
+          )
+        end
+
+        # @api private
+        #
+        # @param client [Anthropic::Client]
+        def initialize(client:)
+          @client = client
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/resources/messages.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Resources
+    class Messages
+      # @return [Anthropic::Resources::Messages::Batches]
+      attr_reader :batches
+
+      # See {Anthropic::Resources::Messages#stream_raw} for streaming counterpart.
+      #
+      # Send a structured list of input messages with text and/or image content, and the
+      # model will generate the next message in the conversation.
+      #
+      # The Messages API can be used for either single queries or stateless multi-turn
+      # conversations.
+      #
+      # Learn more about the Messages API in our [user guide](/en/docs/initial-setup)
+      #
+      # @overload create(max_tokens:, messages:, model:, metadata: nil, stop_sequences: nil, system_: nil, temperature: nil, thinking: nil, tool_choice: nil, tools: nil, top_k: nil, top_p: nil, request_options: {})
+      #
+      # @param max_tokens [Integer]
+      # @param messages [Array<Anthropic::Models::MessageParam>]
+      # @param model [Symbol, String, Anthropic::Models::Model]
+      # @param metadata [Anthropic::Models::Metadata]
+      # @param stop_sequences [Array<String>]
+      # @param system_ [String, Array<Anthropic::Models::TextBlockParam>]
+      # @param temperature [Float]
+      # @param thinking [Anthropic::Models::ThinkingConfigEnabled, Anthropic::Models::ThinkingConfigDisabled]
+      # @param tool_choice [Anthropic::Models::ToolChoiceAuto, Anthropic::Models::ToolChoiceAny, Anthropic::Models::ToolChoiceTool, Anthropic::Models::ToolChoiceNone]
+      # @param tools [Array<Anthropic::Models::Tool, Anthropic::Models::ToolBash20250124, Anthropic::Models::ToolTextEditor20250124>]
+      # @param top_k [Integer]
+      # @param top_p [Float]
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Models::Message]
+      #
+      # @see Anthropic::Models::MessageCreateParams
+      def create(params)
+        parsed, options = Anthropic::Models::MessageCreateParams.dump_request(params)
+        if parsed[:stream]
+          message = "Please use `#stream_raw` for the streaming use case."
+          raise ArgumentError.new(message)
+        end
+        @client.request(
+          method: :post,
+          path: "v1/messages",
+          body: parsed,
+          model: Anthropic::Models::Message,
+          options: options
+        )
+      end
+
+      def stream
+        raise NotImplementedError.new("higher level helpers are coming soon!")
+      end
+
+      # See {Anthropic::Resources::Messages#create} for non-streaming counterpart.
+      #
+      # Send a structured list of input messages with text and/or image content, and the
+      # model will generate the next message in the conversation.
+      #
+      # The Messages API can be used for either single queries or stateless multi-turn
+      # conversations.
+      #
+      # Learn more about the Messages API in our [user guide](/en/docs/initial-setup)
+      #
+      # @overload stream_raw(max_tokens:, messages:, model:, metadata: nil, stop_sequences: nil, system_: nil, temperature: nil, thinking: nil, tool_choice: nil, tools: nil, top_k: nil, top_p: nil, request_options: {})
+      #
+      # @param max_tokens [Integer]
+      # @param messages [Array<Anthropic::Models::MessageParam>]
+      # @param model [Symbol, String, Anthropic::Models::Model]
+      # @param metadata [Anthropic::Models::Metadata]
+      # @param stop_sequences [Array<String>]
+      # @param system_ [String, Array<Anthropic::Models::TextBlockParam>]
+      # @param temperature [Float]
+      # @param thinking [Anthropic::Models::ThinkingConfigEnabled, Anthropic::Models::ThinkingConfigDisabled]
+      # @param tool_choice [Anthropic::Models::ToolChoiceAuto, Anthropic::Models::ToolChoiceAny, Anthropic::Models::ToolChoiceTool, Anthropic::Models::ToolChoiceNone]
+      # @param tools [Array<Anthropic::Models::Tool, Anthropic::Models::ToolBash20250124, Anthropic::Models::ToolTextEditor20250124>]
+      # @param top_k [Integer]
+      # @param top_p [Float]
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Internal::Stream<Anthropic::Models::RawMessageStartEvent, Anthropic::Models::RawMessageDeltaEvent, Anthropic::Models::RawMessageStopEvent, Anthropic::Models::RawContentBlockStartEvent, Anthropic::Models::RawContentBlockDeltaEvent, Anthropic::Models::RawContentBlockStopEvent>]
+      #
+      # @see Anthropic::Models::MessageCreateParams
+      def stream_raw(params)
+        parsed, options = Anthropic::Models::MessageCreateParams.dump_request(params)
+        unless parsed.fetch(:stream, true)
+          message = "Please use `#create` for the non-streaming use case."
+          raise ArgumentError.new(message)
+        end
+        parsed.store(:stream, true)
+        @client.request(
+          method: :post,
+          path: "v1/messages",
+          headers: {"accept" => "text/event-stream"},
+          body: parsed,
+          stream: Anthropic::Internal::Stream,
+          model: Anthropic::Models::RawMessageStreamEvent,
+          options: options
+        )
+      end
+
+      # Count the number of tokens in a Message.
+      #
+      # The Token Count API can be used to count the number of tokens in a Message,
+      # including tools, images, and documents, without creating it.
+      #
+      # Learn more about token counting in our
+      # [user guide](/en/docs/build-with-claude/token-counting)
+      #
+      # @overload count_tokens(messages:, model:, system_: nil, thinking: nil, tool_choice: nil, tools: nil, request_options: {})
+      #
+      # @param messages [Array<Anthropic::Models::MessageParam>]
+      # @param model [Symbol, String, Anthropic::Models::Model]
+      # @param system_ [String, Array<Anthropic::Models::TextBlockParam>]
+      # @param thinking [Anthropic::Models::ThinkingConfigEnabled, Anthropic::Models::ThinkingConfigDisabled]
+      # @param tool_choice [Anthropic::Models::ToolChoiceAuto, Anthropic::Models::ToolChoiceAny, Anthropic::Models::ToolChoiceTool, Anthropic::Models::ToolChoiceNone]
+      # @param tools [Array<Anthropic::Models::Tool, Anthropic::Models::ToolBash20250124, Anthropic::Models::ToolTextEditor20250124>]
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Models::MessageTokensCount]
+      #
+      # @see Anthropic::Models::MessageCountTokensParams
+      def count_tokens(params)
+        parsed, options = Anthropic::Models::MessageCountTokensParams.dump_request(params)
+        @client.request(
+          method: :post,
+          path: "v1/messages/count_tokens",
+          body: parsed,
+          model: Anthropic::Models::MessageTokensCount,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Anthropic::Client]
+      def initialize(client:)
+        @client = client
+        @batches = Anthropic::Resources::Messages::Batches.new(client: client)
+      end
+    end
+  end
+end

data/lib/anthropic/resources/models.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Resources
+    class Models
+      # Get a specific model.
+      #
+      # The Models API response can be used to determine information about a specific
+      # model or resolve a model alias to a model ID.
+      #
+      # @overload retrieve(model_id, request_options: {})
+      #
+      # @param model_id [String]
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Models::ModelInfo]
+      #
+      # @see Anthropic::Models::ModelRetrieveParams
+      def retrieve(model_id, params = {})
+        @client.request(
+          method: :get,
+          path: ["v1/models/%1$s", model_id],
+          model: Anthropic::Models::ModelInfo,
+          options: params[:request_options]
+        )
+      end
+
+      # List available models.
+      #
+      # The Models API response can be used to determine which models are available for
+      # use in the API. More recently released models are listed first.
+      #
+      # @overload list(after_id: nil, before_id: nil, limit: nil, request_options: {})
+      #
+      # @param after_id [String]
+      # @param before_id [String]
+      # @param limit [Integer]
+      # @param request_options [Anthropic::RequestOptions, Hash{Symbol=>Object}, nil]
+      #
+      # @return [Anthropic::Internal::Page<Anthropic::Models::ModelInfo>]
+      #
+      # @see Anthropic::Models::ModelListParams
+      def list(params = {})
+        parsed, options = Anthropic::Models::ModelListParams.dump_request(params)
+        @client.request(
+          method: :get,
+          path: "v1/models",
+          query: parsed,
+          page: Anthropic::Internal::Page,
+          model: Anthropic::Models::ModelInfo,
+          options: options
+        )
+      end
+
+      # @api private
+      #
+      # @param client [Anthropic::Client]
+      def initialize(client:)
+        @client = client
+      end
+    end
+  end
+end

data/lib/anthropic/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Anthropic
+  VERSION = "0.1.0.pre.beta.3"
+end