openai 0.1.0.pre.beta.2 → 0.1.0

data/rbi/openai/resources/audio/transcriptions.rbi

@@ -1,178 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class Audio
-      class Transcriptions
-        # See {OpenAI::Resources::Audio::Transcriptions#create_streaming} for streaming
-        # counterpart.
-        #
-        # Transcribes audio into the input language.
-        sig do
-          params(
-            file: OpenAI::Internal::FileInput,
-            model: T.any(String, OpenAI::AudioModel::OrSymbol),
-            chunking_strategy:
-              T.nilable(
-                T.any(
-                  Symbol,
-                  OpenAI::Audio::TranscriptionCreateParams::ChunkingStrategy::VadConfig::OrHash
-                )
-              ),
-            include: T::Array[OpenAI::Audio::TranscriptionInclude::OrSymbol],
-            language: String,
-            prompt: String,
-            response_format: OpenAI::AudioResponseFormat::OrSymbol,
-            temperature: Float,
-            timestamp_granularities:
-              T::Array[
-                OpenAI::Audio::TranscriptionCreateParams::TimestampGranularity::OrSymbol
-              ],
-            stream: T.noreturn,
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(
-            OpenAI::Models::Audio::TranscriptionCreateResponse::Variants
-          )
-        end
-        def create(
-          # The audio file object (not file name) to transcribe, in one of these formats:
-          # flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
-          file:,
-          # ID of the model to use. The options are `gpt-4o-transcribe`,
-          # `gpt-4o-mini-transcribe`, and `whisper-1` (which is powered by our open source
-          # Whisper V2 model).
-          model:,
-          # Controls how the audio is cut into chunks. When set to `"auto"`, the server
-          # first normalizes loudness and then uses voice activity detection (VAD) to choose
-          # boundaries. `server_vad` object can be provided to tweak VAD detection
-          # parameters manually. If unset, the audio is transcribed as a single block.
-          chunking_strategy: nil,
-          # Additional information to include in the transcription response. `logprobs` will
-          # return the log probabilities of the tokens in the response to understand the
-          # model's confidence in the transcription. `logprobs` only works with
-          # response_format set to `json` and only with the models `gpt-4o-transcribe` and
-          # `gpt-4o-mini-transcribe`.
-          include: nil,
-          # The language of the input audio. Supplying the input language in
-          # [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
-          # format will improve accuracy and latency.
-          language: nil,
-          # An optional text to guide the model's style or continue a previous audio
-          # segment. The
-          # [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
-          # should match the audio language.
-          prompt: nil,
-          # The format of the output, in one of these options: `json`, `text`, `srt`,
-          # `verbose_json`, or `vtt`. For `gpt-4o-transcribe` and `gpt-4o-mini-transcribe`,
-          # the only supported format is `json`.
-          response_format: nil,
-          # The sampling temperature, between 0 and 1. Higher values like 0.8 will make the
-          # output more random, while lower values like 0.2 will make it more focused and
-          # deterministic. If set to 0, the model will use
-          # [log probability](https://en.wikipedia.org/wiki/Log_probability) to
-          # automatically increase the temperature until certain thresholds are hit.
-          temperature: nil,
-          # The timestamp granularities to populate for this transcription.
-          # `response_format` must be set `verbose_json` to use timestamp granularities.
-          # Either or both of these options are supported: `word`, or `segment`. Note: There
-          # is no additional latency for segment timestamps, but generating word timestamps
-          # incurs additional latency.
-          timestamp_granularities: nil,
-          # There is no need to provide `stream:`. Instead, use `#create_streaming` or
-          # `#create` for streaming and non-streaming use cases, respectively.
-          stream: false,
-          request_options: {}
-        )
-        end
-
-        # See {OpenAI::Resources::Audio::Transcriptions#create} for non-streaming
-        # counterpart.
-        #
-        # Transcribes audio into the input language.
-        sig do
-          params(
-            file: OpenAI::Internal::FileInput,
-            model: T.any(String, OpenAI::AudioModel::OrSymbol),
-            chunking_strategy:
-              T.nilable(
-                T.any(
-                  Symbol,
-                  OpenAI::Audio::TranscriptionCreateParams::ChunkingStrategy::VadConfig::OrHash
-                )
-              ),
-            include: T::Array[OpenAI::Audio::TranscriptionInclude::OrSymbol],
-            language: String,
-            prompt: String,
-            response_format: OpenAI::AudioResponseFormat::OrSymbol,
-            temperature: Float,
-            timestamp_granularities:
-              T::Array[
-                OpenAI::Audio::TranscriptionCreateParams::TimestampGranularity::OrSymbol
-              ],
-            stream: T.noreturn,
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(
-            OpenAI::Internal::Stream[
-              OpenAI::Audio::TranscriptionStreamEvent::Variants
-            ]
-          )
-        end
-        def create_streaming(
-          # The audio file object (not file name) to transcribe, in one of these formats:
-          # flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
-          file:,
-          # ID of the model to use. The options are `gpt-4o-transcribe`,
-          # `gpt-4o-mini-transcribe`, and `whisper-1` (which is powered by our open source
-          # Whisper V2 model).
-          model:,
-          # Controls how the audio is cut into chunks. When set to `"auto"`, the server
-          # first normalizes loudness and then uses voice activity detection (VAD) to choose
-          # boundaries. `server_vad` object can be provided to tweak VAD detection
-          # parameters manually. If unset, the audio is transcribed as a single block.
-          chunking_strategy: nil,
-          # Additional information to include in the transcription response. `logprobs` will
-          # return the log probabilities of the tokens in the response to understand the
-          # model's confidence in the transcription. `logprobs` only works with
-          # response_format set to `json` and only with the models `gpt-4o-transcribe` and
-          # `gpt-4o-mini-transcribe`.
-          include: nil,
-          # The language of the input audio. Supplying the input language in
-          # [ISO-639-1](https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) (e.g. `en`)
-          # format will improve accuracy and latency.
-          language: nil,
-          # An optional text to guide the model's style or continue a previous audio
-          # segment. The
-          # [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
-          # should match the audio language.
-          prompt: nil,
-          # The format of the output, in one of these options: `json`, `text`, `srt`,
-          # `verbose_json`, or `vtt`. For `gpt-4o-transcribe` and `gpt-4o-mini-transcribe`,
-          # the only supported format is `json`.
-          response_format: nil,
-          # The sampling temperature, between 0 and 1. Higher values like 0.8 will make the
-          # output more random, while lower values like 0.2 will make it more focused and
-          # deterministic. If set to 0, the model will use
-          # [log probability](https://en.wikipedia.org/wiki/Log_probability) to
-          # automatically increase the temperature until certain thresholds are hit.
-          temperature: nil,
-          # The timestamp granularities to populate for this transcription.
-          # `response_format` must be set `verbose_json` to use timestamp granularities.
-          # Either or both of these options are supported: `word`, or `segment`. Note: There
-          # is no additional latency for segment timestamps, but generating word timestamps
-          # incurs additional latency.
-          timestamp_granularities: nil,
-          # There is no need to provide `stream:`. Instead, use `#create_streaming` or
-          # `#create` for streaming and non-streaming use cases, respectively.
-          stream: true,
-          request_options: {}
-        )
-        end
-
-        # @api private
-        sig { params(client: OpenAI::Client).returns(T.attached_class) }
-        def self.new(client:)
-        end
-      end
-    end
-  end
-end

data/rbi/openai/resources/audio/translations.rbi

@@ -1,51 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class Audio
-      class Translations
-        # Translates audio into English.
-        sig do
-          params(
-            file: OpenAI::Internal::FileInput,
-            model: T.any(String, OpenAI::AudioModel::OrSymbol),
-            prompt: String,
-            response_format:
-              OpenAI::Audio::TranslationCreateParams::ResponseFormat::OrSymbol,
-            temperature: Float,
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(OpenAI::Models::Audio::TranslationCreateResponse::Variants)
-        end
-        def create(
-          # The audio file object (not file name) translate, in one of these formats: flac,
-          # mp3, mp4, mpeg, mpga, m4a, ogg, wav, or webm.
-          file:,
-          # ID of the model to use. Only `whisper-1` (which is powered by our open source
-          # Whisper V2 model) is currently available.
-          model:,
-          # An optional text to guide the model's style or continue a previous audio
-          # segment. The
-          # [prompt](https://platform.openai.com/docs/guides/speech-to-text#prompting)
-          # should be in English.
-          prompt: nil,
-          # The format of the output, in one of these options: `json`, `text`, `srt`,
-          # `verbose_json`, or `vtt`.
-          response_format: nil,
-          # The sampling temperature, between 0 and 1. Higher values like 0.8 will make the
-          # output more random, while lower values like 0.2 will make it more focused and
-          # deterministic. If set to 0, the model will use
-          # [log probability](https://en.wikipedia.org/wiki/Log_probability) to
-          # automatically increase the temperature until certain thresholds are hit.
-          temperature: nil,
-          request_options: {}
-        )
-        end
-
-        # @api private
-        sig { params(client: OpenAI::Client).returns(T.attached_class) }
-        def self.new(client:)
-        end
-      end
-    end
-  end
-end

data/rbi/openai/resources/audio.rbi

@@ -1,21 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class Audio
-      sig { returns(OpenAI::Resources::Audio::Transcriptions) }
-      attr_reader :transcriptions
-
-      sig { returns(OpenAI::Resources::Audio::Translations) }
-      attr_reader :translations
-
-      sig { returns(OpenAI::Resources::Audio::Speech) }
-      attr_reader :speech
-
-      # @api private
-      sig { params(client: OpenAI::Client).returns(T.attached_class) }
-      def self.new(client:)
-      end
-    end
-  end
-end

data/rbi/openai/resources/batches.rbi

@@ -1,104 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class Batches
-      # Creates and executes a batch from an uploaded file of requests
-      sig do
-        params(
-          completion_window:
-            OpenAI::BatchCreateParams::CompletionWindow::OrSymbol,
-          endpoint: OpenAI::BatchCreateParams::Endpoint::OrSymbol,
-          input_file_id: String,
-          metadata: T.nilable(T::Hash[Symbol, String]),
-          request_options: OpenAI::RequestOptions::OrHash
-        ).returns(OpenAI::Batch)
-      end
-      def create(
-        # The time frame within which the batch should be processed. Currently only `24h`
-        # is supported.
-        completion_window:,
-        # The endpoint to be used for all requests in the batch. Currently
-        # `/v1/responses`, `/v1/chat/completions`, `/v1/embeddings`, and `/v1/completions`
-        # are supported. Note that `/v1/embeddings` batches are also restricted to a
-        # maximum of 50,000 embedding inputs across all requests in the batch.
-        endpoint:,
-        # The ID of an uploaded file that contains requests for the new batch.
-        #
-        # See [upload file](https://platform.openai.com/docs/api-reference/files/create)
-        # for how to upload a file.
-        #
-        # Your input file must be formatted as a
-        # [JSONL file](https://platform.openai.com/docs/api-reference/batch/request-input),
-        # and must be uploaded with the purpose `batch`. The file can contain up to 50,000
-        # requests, and can be up to 200 MB in size.
-        input_file_id:,
-        # Set of 16 key-value pairs that can be attached to an object. This can be useful
-        # for storing additional information about the object in a structured format, and
-        # querying for objects via API or the dashboard.
-        #
-        # Keys are strings with a maximum length of 64 characters. Values are strings with
-        # a maximum length of 512 characters.
-        metadata: nil,
-        request_options: {}
-      )
-      end
-
-      # Retrieves a batch.
-      sig do
-        params(
-          batch_id: String,
-          request_options: OpenAI::RequestOptions::OrHash
-        ).returns(OpenAI::Batch)
-      end
-      def retrieve(
-        # The ID of the batch to retrieve.
-        batch_id,
-        request_options: {}
-      )
-      end
-
-      # List your organization's batches.
-      sig do
-        params(
-          after: String,
-          limit: Integer,
-          request_options: OpenAI::RequestOptions::OrHash
-        ).returns(OpenAI::Internal::CursorPage[OpenAI::Batch])
-      end
-      def list(
-        # A cursor for use in pagination. `after` is an object ID that defines your place
-        # in the list. For instance, if you make a list request and receive 100 objects,
-        # ending with obj_foo, your subsequent call can include after=obj_foo in order to
-        # fetch the next page of the list.
-        after: nil,
-        # A limit on the number of objects to be returned. Limit can range between 1 and
-        # 100, and the default is 20.
-        limit: nil,
-        request_options: {}
-      )
-      end
-
-      # Cancels an in-progress batch. The batch will be in status `cancelling` for up to
-      # 10 minutes, before changing to `cancelled`, where it will have partial results
-      # (if any) available in the output file.
-      sig do
-        params(
-          batch_id: String,
-          request_options: OpenAI::RequestOptions::OrHash
-        ).returns(OpenAI::Batch)
-      end
-      def cancel(
-        # The ID of the batch to cancel.
-        batch_id,
-        request_options: {}
-      )
-      end
-
-      # @api private
-      sig { params(client: OpenAI::Client).returns(T.attached_class) }
-      def self.new(client:)
-      end
-    end
-  end
-end

data/rbi/openai/resources/beta/assistants.rbi

@@ -1,294 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class Beta
-      class Assistants
-        # Create an assistant with a model and instructions.
-        sig do
-          params(
-            model: T.any(String, OpenAI::ChatModel::OrSymbol),
-            description: T.nilable(String),
-            instructions: T.nilable(String),
-            metadata: T.nilable(T::Hash[Symbol, String]),
-            name: T.nilable(String),
-            reasoning_effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol),
-            response_format:
-              T.nilable(
-                T.any(
-                  Symbol,
-                  OpenAI::ResponseFormatText::OrHash,
-                  OpenAI::ResponseFormatJSONObject::OrHash,
-                  OpenAI::ResponseFormatJSONSchema::OrHash
-                )
-              ),
-            temperature: T.nilable(Float),
-            tool_resources:
-              T.nilable(
-                OpenAI::Beta::AssistantCreateParams::ToolResources::OrHash
-              ),
-            tools:
-              T::Array[
-                T.any(
-                  OpenAI::Beta::CodeInterpreterTool::OrHash,
-                  OpenAI::Beta::FileSearchTool::OrHash,
-                  OpenAI::Beta::FunctionTool::OrHash
-                )
-              ],
-            top_p: T.nilable(Float),
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(OpenAI::Beta::Assistant)
-        end
-        def create(
-          # ID of the model to use. You can use the
-          # [List models](https://platform.openai.com/docs/api-reference/models/list) API to
-          # see all of your available models, or see our
-          # [Model overview](https://platform.openai.com/docs/models) for descriptions of
-          # them.
-          model:,
-          # The description of the assistant. The maximum length is 512 characters.
-          description: nil,
-          # The system instructions that the assistant uses. The maximum length is 256,000
-          # characters.
-          instructions: nil,
-          # Set of 16 key-value pairs that can be attached to an object. This can be useful
-          # for storing additional information about the object in a structured format, and
-          # querying for objects via API or the dashboard.
-          #
-          # Keys are strings with a maximum length of 64 characters. Values are strings with
-          # a maximum length of 512 characters.
-          metadata: nil,
-          # The name of the assistant. The maximum length is 256 characters.
-          name: nil,
-          # **o-series models only**
-          #
-          # Constrains effort on reasoning for
-          # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-          # supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-          # result in faster responses and fewer tokens used on reasoning in a response.
-          reasoning_effort: nil,
-          # Specifies the format that the model must output. Compatible with
-          # [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
-          # [GPT-4 Turbo](https://platform.openai.com/docs/models#gpt-4-turbo-and-gpt-4),
-          # and all GPT-3.5 Turbo models since `gpt-3.5-turbo-1106`.
-          #
-          # Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
-          # Outputs which ensures the model will match your supplied JSON schema. Learn more
-          # in the
-          # [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
-          #
-          # Setting to `{ "type": "json_object" }` enables JSON mode, which ensures the
-          # message the model generates is valid JSON.
-          #
-          # **Important:** when using JSON mode, you **must** also instruct the model to
-          # produce JSON yourself via a system or user message. Without this, the model may
-          # generate an unending stream of whitespace until the generation reaches the token
-          # limit, resulting in a long-running and seemingly "stuck" request. Also note that
-          # the message content may be partially cut off if `finish_reason="length"`, which
-          # indicates the generation exceeded `max_tokens` or the conversation exceeded the
-          # max context length.
-          response_format: nil,
-          # What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
-          # make the output more random, while lower values like 0.2 will make it more
-          # focused and deterministic.
-          temperature: nil,
-          # A set of resources that are used by the assistant's tools. The resources are
-          # specific to the type of tool. For example, the `code_interpreter` tool requires
-          # a list of file IDs, while the `file_search` tool requires a list of vector store
-          # IDs.
-          tool_resources: nil,
-          # A list of tool enabled on the assistant. There can be a maximum of 128 tools per
-          # assistant. Tools can be of types `code_interpreter`, `file_search`, or
-          # `function`.
-          tools: nil,
-          # An alternative to sampling with temperature, called nucleus sampling, where the
-          # model considers the results of the tokens with top_p probability mass. So 0.1
-          # means only the tokens comprising the top 10% probability mass are considered.
-          #
-          # We generally recommend altering this or temperature but not both.
-          top_p: nil,
-          request_options: {}
-        )
-        end
-
-        # Retrieves an assistant.
-        sig do
-          params(
-            assistant_id: String,
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(OpenAI::Beta::Assistant)
-        end
-        def retrieve(
-          # The ID of the assistant to retrieve.
-          assistant_id,
-          request_options: {}
-        )
-        end
-
-        # Modifies an assistant.
-        sig do
-          params(
-            assistant_id: String,
-            description: T.nilable(String),
-            instructions: T.nilable(String),
-            metadata: T.nilable(T::Hash[Symbol, String]),
-            model:
-              T.any(
-                String,
-                OpenAI::Beta::AssistantUpdateParams::Model::OrSymbol
-              ),
-            name: T.nilable(String),
-            reasoning_effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol),
-            response_format:
-              T.nilable(
-                T.any(
-                  Symbol,
-                  OpenAI::ResponseFormatText::OrHash,
-                  OpenAI::ResponseFormatJSONObject::OrHash,
-                  OpenAI::ResponseFormatJSONSchema::OrHash
-                )
-              ),
-            temperature: T.nilable(Float),
-            tool_resources:
-              T.nilable(
-                OpenAI::Beta::AssistantUpdateParams::ToolResources::OrHash
-              ),
-            tools:
-              T::Array[
-                T.any(
-                  OpenAI::Beta::CodeInterpreterTool::OrHash,
-                  OpenAI::Beta::FileSearchTool::OrHash,
-                  OpenAI::Beta::FunctionTool::OrHash
-                )
-              ],
-            top_p: T.nilable(Float),
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(OpenAI::Beta::Assistant)
-        end
-        def update(
-          # The ID of the assistant to modify.
-          assistant_id,
-          # The description of the assistant. The maximum length is 512 characters.
-          description: nil,
-          # The system instructions that the assistant uses. The maximum length is 256,000
-          # characters.
-          instructions: nil,
-          # Set of 16 key-value pairs that can be attached to an object. This can be useful
-          # for storing additional information about the object in a structured format, and
-          # querying for objects via API or the dashboard.
-          #
-          # Keys are strings with a maximum length of 64 characters. Values are strings with
-          # a maximum length of 512 characters.
-          metadata: nil,
-          # ID of the model to use. You can use the
-          # [List models](https://platform.openai.com/docs/api-reference/models/list) API to
-          # see all of your available models, or see our
-          # [Model overview](https://platform.openai.com/docs/models) for descriptions of
-          # them.
-          model: nil,
-          # The name of the assistant. The maximum length is 256 characters.
-          name: nil,
-          # **o-series models only**
-          #
-          # Constrains effort on reasoning for
-          # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-          # supported values are `low`, `medium`, and `high`. Reducing reasoning effort can
-          # result in faster responses and fewer tokens used on reasoning in a response.
-          reasoning_effort: nil,
-          # Specifies the format that the model must output. Compatible with
-          # [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
-          # [GPT-4 Turbo](https://platform.openai.com/docs/models#gpt-4-turbo-and-gpt-4),
-          # and all GPT-3.5 Turbo models since `gpt-3.5-turbo-1106`.
-          #
-          # Setting to `{ "type": "json_schema", "json_schema": {...} }` enables Structured
-          # Outputs which ensures the model will match your supplied JSON schema. Learn more
-          # in the
-          # [Structured Outputs guide](https://platform.openai.com/docs/guides/structured-outputs).
-          #
-          # Setting to `{ "type": "json_object" }` enables JSON mode, which ensures the
-          # message the model generates is valid JSON.
-          #
-          # **Important:** when using JSON mode, you **must** also instruct the model to
-          # produce JSON yourself via a system or user message. Without this, the model may
-          # generate an unending stream of whitespace until the generation reaches the token
-          # limit, resulting in a long-running and seemingly "stuck" request. Also note that
-          # the message content may be partially cut off if `finish_reason="length"`, which
-          # indicates the generation exceeded `max_tokens` or the conversation exceeded the
-          # max context length.
-          response_format: nil,
-          # What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
-          # make the output more random, while lower values like 0.2 will make it more
-          # focused and deterministic.
-          temperature: nil,
-          # A set of resources that are used by the assistant's tools. The resources are
-          # specific to the type of tool. For example, the `code_interpreter` tool requires
-          # a list of file IDs, while the `file_search` tool requires a list of vector store
-          # IDs.
-          tool_resources: nil,
-          # A list of tool enabled on the assistant. There can be a maximum of 128 tools per
-          # assistant. Tools can be of types `code_interpreter`, `file_search`, or
-          # `function`.
-          tools: nil,
-          # An alternative to sampling with temperature, called nucleus sampling, where the
-          # model considers the results of the tokens with top_p probability mass. So 0.1
-          # means only the tokens comprising the top 10% probability mass are considered.
-          #
-          # We generally recommend altering this or temperature but not both.
-          top_p: nil,
-          request_options: {}
-        )
-        end
-
-        # Returns a list of assistants.
-        sig do
-          params(
-            after: String,
-            before: String,
-            limit: Integer,
-            order: OpenAI::Beta::AssistantListParams::Order::OrSymbol,
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(OpenAI::Internal::CursorPage[OpenAI::Beta::Assistant])
-        end
-        def list(
-          # A cursor for use in pagination. `after` is an object ID that defines your place
-          # in the list. For instance, if you make a list request and receive 100 objects,
-          # ending with obj_foo, your subsequent call can include after=obj_foo in order to
-          # fetch the next page of the list.
-          after: nil,
-          # A cursor for use in pagination. `before` is an object ID that defines your place
-          # in the list. For instance, if you make a list request and receive 100 objects,
-          # starting with obj_foo, your subsequent call can include before=obj_foo in order
-          # to fetch the previous page of the list.
-          before: nil,
-          # A limit on the number of objects to be returned. Limit can range between 1 and
-          # 100, and the default is 20.
-          limit: nil,
-          # Sort order by the `created_at` timestamp of the objects. `asc` for ascending
-          # order and `desc` for descending order.
-          order: nil,
-          request_options: {}
-        )
-        end
-
-        # Delete an assistant.
-        sig do
-          params(
-            assistant_id: String,
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(OpenAI::Beta::AssistantDeleted)
-        end
-        def delete(
-          # The ID of the assistant to delete.
-          assistant_id,
-          request_options: {}
-        )
-        end
-
-        # @api private
-        sig { params(client: OpenAI::Client).returns(T.attached_class) }
-        def self.new(client:)
-        end
-      end
-    end
-  end
-end