openai 0.1.0.pre.beta.2 → 0.1.0

data/rbi/openai/resources/fine_tuning/jobs.rbi

@@ -1,214 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class FineTuning
-      class Jobs
-        sig { returns(OpenAI::Resources::FineTuning::Jobs::Checkpoints) }
-        attr_reader :checkpoints
-
-        # Creates a fine-tuning job which begins the process of creating a new model from
-        # a given dataset.
-        #
-        # Response includes details of the enqueued job including job status and the name
-        # of the fine-tuned models once complete.
-        #
-        # [Learn more about fine-tuning](https://platform.openai.com/docs/guides/fine-tuning)
-        sig do
-          params(
-            model:
-              T.any(
-                String,
-                OpenAI::FineTuning::JobCreateParams::Model::OrSymbol
-              ),
-            training_file: String,
-            hyperparameters:
-              OpenAI::FineTuning::JobCreateParams::Hyperparameters::OrHash,
-            integrations:
-              T.nilable(
-                T::Array[
-                  OpenAI::FineTuning::JobCreateParams::Integration::OrHash
-                ]
-              ),
-            metadata: T.nilable(T::Hash[Symbol, String]),
-            method_: OpenAI::FineTuning::JobCreateParams::Method::OrHash,
-            seed: T.nilable(Integer),
-            suffix: T.nilable(String),
-            validation_file: T.nilable(String),
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(OpenAI::FineTuning::FineTuningJob)
-        end
-        def create(
-          # The name of the model to fine-tune. You can select one of the
-          # [supported models](https://platform.openai.com/docs/guides/fine-tuning#which-models-can-be-fine-tuned).
-          model:,
-          # The ID of an uploaded file that contains training data.
-          #
-          # See [upload file](https://platform.openai.com/docs/api-reference/files/create)
-          # for how to upload a file.
-          #
-          # Your dataset must be formatted as a JSONL file. Additionally, you must upload
-          # your file with the purpose `fine-tune`.
-          #
-          # The contents of the file should differ depending on if the model uses the
-          # [chat](https://platform.openai.com/docs/api-reference/fine-tuning/chat-input),
-          # [completions](https://platform.openai.com/docs/api-reference/fine-tuning/completions-input)
-          # format, or if the fine-tuning method uses the
-          # [preference](https://platform.openai.com/docs/api-reference/fine-tuning/preference-input)
-          # format.
-          #
-          # See the [fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning)
-          # for more details.
-          training_file:,
-          # The hyperparameters used for the fine-tuning job. This value is now deprecated
-          # in favor of `method`, and should be passed in under the `method` parameter.
-          hyperparameters: nil,
-          # A list of integrations to enable for your fine-tuning job.
-          integrations: 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 method used for fine-tuning.
-          method_: nil,
-          # The seed controls the reproducibility of the job. Passing in the same seed and
-          # job parameters should produce the same results, but may differ in rare cases. If
-          # a seed is not specified, one will be generated for you.
-          seed: nil,
-          # A string of up to 64 characters that will be added to your fine-tuned model
-          # name.
-          #
-          # For example, a `suffix` of "custom-model-name" would produce a model name like
-          # `ft:gpt-4o-mini:openai:custom-model-name:7p4lURel`.
-          suffix: nil,
-          # The ID of an uploaded file that contains validation data.
-          #
-          # If you provide this file, the data is used to generate validation metrics
-          # periodically during fine-tuning. These metrics can be viewed in the fine-tuning
-          # results file. The same data should not be present in both train and validation
-          # files.
-          #
-          # Your dataset must be formatted as a JSONL file. You must upload your file with
-          # the purpose `fine-tune`.
-          #
-          # See the [fine-tuning guide](https://platform.openai.com/docs/guides/fine-tuning)
-          # for more details.
-          validation_file: nil,
-          request_options: {}
-        )
-        end
-
-        # Get info about a fine-tuning job.
-        #
-        # [Learn more about fine-tuning](https://platform.openai.com/docs/guides/fine-tuning)
-        sig do
-          params(
-            fine_tuning_job_id: String,
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(OpenAI::FineTuning::FineTuningJob)
-        end
-        def retrieve(
-          # The ID of the fine-tuning job.
-          fine_tuning_job_id,
-          request_options: {}
-        )
-        end
-
-        # List your organization's fine-tuning jobs
-        sig do
-          params(
-            after: String,
-            limit: Integer,
-            metadata: T.nilable(T::Hash[Symbol, String]),
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(
-            OpenAI::Internal::CursorPage[OpenAI::FineTuning::FineTuningJob]
-          )
-        end
-        def list(
-          # Identifier for the last job from the previous pagination request.
-          after: nil,
-          # Number of fine-tuning jobs to retrieve.
-          limit: nil,
-          # Optional metadata filter. To filter, use the syntax `metadata[k]=v`.
-          # Alternatively, set `metadata=null` to indicate no metadata.
-          metadata: nil,
-          request_options: {}
-        )
-        end
-
-        # Immediately cancel a fine-tune job.
-        sig do
-          params(
-            fine_tuning_job_id: String,
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(OpenAI::FineTuning::FineTuningJob)
-        end
-        def cancel(
-          # The ID of the fine-tuning job to cancel.
-          fine_tuning_job_id,
-          request_options: {}
-        )
-        end
-
-        # Get status updates for a fine-tuning job.
-        sig do
-          params(
-            fine_tuning_job_id: String,
-            after: String,
-            limit: Integer,
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(
-            OpenAI::Internal::CursorPage[OpenAI::FineTuning::FineTuningJobEvent]
-          )
-        end
-        def list_events(
-          # The ID of the fine-tuning job to get events for.
-          fine_tuning_job_id,
-          # Identifier for the last event from the previous pagination request.
-          after: nil,
-          # Number of events to retrieve.
-          limit: nil,
-          request_options: {}
-        )
-        end
-
-        # Pause a fine-tune job.
-        sig do
-          params(
-            fine_tuning_job_id: String,
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(OpenAI::FineTuning::FineTuningJob)
-        end
-        def pause(
-          # The ID of the fine-tuning job to pause.
-          fine_tuning_job_id,
-          request_options: {}
-        )
-        end
-
-        # Resume a fine-tune job.
-        sig do
-          params(
-            fine_tuning_job_id: String,
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(OpenAI::FineTuning::FineTuningJob)
-        end
-        def resume(
-          # The ID of the fine-tuning job to resume.
-          fine_tuning_job_id,
-          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/fine_tuning/methods.rbi

@@ -1,14 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class FineTuning
-      class Methods
-        # @api private
-        sig { params(client: OpenAI::Client).returns(T.attached_class) }
-        def self.new(client:)
-        end
-      end
-    end
-  end
-end

data/rbi/openai/resources/fine_tuning.rbi

@@ -1,24 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class FineTuning
-      sig { returns(OpenAI::Resources::FineTuning::Methods) }
-      attr_reader :methods_
-
-      sig { returns(OpenAI::Resources::FineTuning::Jobs) }
-      attr_reader :jobs
-
-      sig { returns(OpenAI::Resources::FineTuning::Checkpoints) }
-      attr_reader :checkpoints
-
-      sig { returns(OpenAI::Resources::FineTuning::Alpha) }
-      attr_reader :alpha
-
-      # @api private
-      sig { params(client: OpenAI::Client).returns(T.attached_class) }
-      def self.new(client:)
-      end
-    end
-  end
-end

data/rbi/openai/resources/graders/grader_models.rbi

@@ -1,14 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class Graders
-      class GraderModels
-        # @api private
-        sig { params(client: OpenAI::Client).returns(T.attached_class) }
-        def self.new(client:)
-        end
-      end
-    end
-  end
-end

data/rbi/openai/resources/graders.rbi

@@ -1,15 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class Graders
-      sig { returns(OpenAI::Resources::Graders::GraderModels) }
-      attr_reader :grader_models
-
-      # @api private
-      sig { params(client: OpenAI::Client).returns(T.attached_class) }
-      def self.new(client:)
-      end
-    end
-  end
-end

data/rbi/openai/resources/images.rbi

@@ -1,205 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class Images
-      # Creates a variation of a given image. This endpoint only supports `dall-e-2`.
-      sig do
-        params(
-          image: OpenAI::Internal::FileInput,
-          model: T.nilable(T.any(String, OpenAI::ImageModel::OrSymbol)),
-          n: T.nilable(Integer),
-          response_format:
-            T.nilable(
-              OpenAI::ImageCreateVariationParams::ResponseFormat::OrSymbol
-            ),
-          size: T.nilable(OpenAI::ImageCreateVariationParams::Size::OrSymbol),
-          user: String,
-          request_options: OpenAI::RequestOptions::OrHash
-        ).returns(OpenAI::ImagesResponse)
-      end
-      def create_variation(
-        # The image to use as the basis for the variation(s). Must be a valid PNG file,
-        # less than 4MB, and square.
-        image:,
-        # The model to use for image generation. Only `dall-e-2` is supported at this
-        # time.
-        model: nil,
-        # The number of images to generate. Must be between 1 and 10.
-        n: nil,
-        # The format in which the generated images are returned. Must be one of `url` or
-        # `b64_json`. URLs are only valid for 60 minutes after the image has been
-        # generated.
-        response_format: nil,
-        # The size of the generated images. Must be one of `256x256`, `512x512`, or
-        # `1024x1024`.
-        size: nil,
-        # A unique identifier representing your end-user, which can help OpenAI to monitor
-        # and detect abuse.
-        # [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
-        user: nil,
-        request_options: {}
-      )
-      end
-
-      # Creates an edited or extended image given one or more source images and a
-      # prompt. This endpoint only supports `gpt-image-1` and `dall-e-2`.
-      sig do
-        params(
-          image: OpenAI::ImageEditParams::Image::Variants,
-          prompt: String,
-          background: T.nilable(OpenAI::ImageEditParams::Background::OrSymbol),
-          mask: OpenAI::Internal::FileInput,
-          model: T.nilable(T.any(String, OpenAI::ImageModel::OrSymbol)),
-          n: T.nilable(Integer),
-          quality: T.nilable(OpenAI::ImageEditParams::Quality::OrSymbol),
-          response_format:
-            T.nilable(OpenAI::ImageEditParams::ResponseFormat::OrSymbol),
-          size: T.nilable(OpenAI::ImageEditParams::Size::OrSymbol),
-          user: String,
-          request_options: OpenAI::RequestOptions::OrHash
-        ).returns(OpenAI::ImagesResponse)
-      end
-      def edit(
-        # The image(s) to edit. Must be a supported image file or an array of images.
-        #
-        # For `gpt-image-1`, each image should be a `png`, `webp`, or `jpg` file less than
-        # 25MB. You can provide up to 16 images.
-        #
-        # For `dall-e-2`, you can only provide one image, and it should be a square `png`
-        # file less than 4MB.
-        image:,
-        # A text description of the desired image(s). The maximum length is 1000
-        # characters for `dall-e-2`, and 32000 characters for `gpt-image-1`.
-        prompt:,
-        # Allows to set transparency for the background of the generated image(s). This
-        # parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
-        # `opaque` or `auto` (default value). When `auto` is used, the model will
-        # automatically determine the best background for the image.
-        #
-        # If `transparent`, the output format needs to support transparency, so it should
-        # be set to either `png` (default value) or `webp`.
-        background: nil,
-        # An additional image whose fully transparent areas (e.g. where alpha is zero)
-        # indicate where `image` should be edited. If there are multiple images provided,
-        # the mask will be applied on the first image. Must be a valid PNG file, less than
-        # 4MB, and have the same dimensions as `image`.
-        mask: nil,
-        # The model to use for image generation. Only `dall-e-2` and `gpt-image-1` are
-        # supported. Defaults to `dall-e-2` unless a parameter specific to `gpt-image-1`
-        # is used.
-        model: nil,
-        # The number of images to generate. Must be between 1 and 10.
-        n: nil,
-        # The quality of the image that will be generated. `high`, `medium` and `low` are
-        # only supported for `gpt-image-1`. `dall-e-2` only supports `standard` quality.
-        # Defaults to `auto`.
-        quality: nil,
-        # The format in which the generated images are returned. Must be one of `url` or
-        # `b64_json`. URLs are only valid for 60 minutes after the image has been
-        # generated. This parameter is only supported for `dall-e-2`, as `gpt-image-1`
-        # will always return base64-encoded images.
-        response_format: nil,
-        # The size of the generated images. Must be one of `1024x1024`, `1536x1024`
-        # (landscape), `1024x1536` (portrait), or `auto` (default value) for
-        # `gpt-image-1`, and one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`.
-        size: nil,
-        # A unique identifier representing your end-user, which can help OpenAI to monitor
-        # and detect abuse.
-        # [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
-        user: nil,
-        request_options: {}
-      )
-      end
-
-      # Creates an image given a prompt.
-      # [Learn more](https://platform.openai.com/docs/guides/images).
-      sig do
-        params(
-          prompt: String,
-          background:
-            T.nilable(OpenAI::ImageGenerateParams::Background::OrSymbol),
-          model: T.nilable(T.any(String, OpenAI::ImageModel::OrSymbol)),
-          moderation:
-            T.nilable(OpenAI::ImageGenerateParams::Moderation::OrSymbol),
-          n: T.nilable(Integer),
-          output_compression: T.nilable(Integer),
-          output_format:
-            T.nilable(OpenAI::ImageGenerateParams::OutputFormat::OrSymbol),
-          quality: T.nilable(OpenAI::ImageGenerateParams::Quality::OrSymbol),
-          response_format:
-            T.nilable(OpenAI::ImageGenerateParams::ResponseFormat::OrSymbol),
-          size: T.nilable(OpenAI::ImageGenerateParams::Size::OrSymbol),
-          style: T.nilable(OpenAI::ImageGenerateParams::Style::OrSymbol),
-          user: String,
-          request_options: OpenAI::RequestOptions::OrHash
-        ).returns(OpenAI::ImagesResponse)
-      end
-      def generate(
-        # A text description of the desired image(s). The maximum length is 32000
-        # characters for `gpt-image-1`, 1000 characters for `dall-e-2` and 4000 characters
-        # for `dall-e-3`.
-        prompt:,
-        # Allows to set transparency for the background of the generated image(s). This
-        # parameter is only supported for `gpt-image-1`. Must be one of `transparent`,
-        # `opaque` or `auto` (default value). When `auto` is used, the model will
-        # automatically determine the best background for the image.
-        #
-        # If `transparent`, the output format needs to support transparency, so it should
-        # be set to either `png` (default value) or `webp`.
-        background: nil,
-        # The model to use for image generation. One of `dall-e-2`, `dall-e-3`, or
-        # `gpt-image-1`. Defaults to `dall-e-2` unless a parameter specific to
-        # `gpt-image-1` is used.
-        model: nil,
-        # Control the content-moderation level for images generated by `gpt-image-1`. Must
-        # be either `low` for less restrictive filtering or `auto` (default value).
-        moderation: nil,
-        # The number of images to generate. Must be between 1 and 10. For `dall-e-3`, only
-        # `n=1` is supported.
-        n: nil,
-        # The compression level (0-100%) for the generated images. This parameter is only
-        # supported for `gpt-image-1` with the `webp` or `jpeg` output formats, and
-        # defaults to 100.
-        output_compression: nil,
-        # The format in which the generated images are returned. This parameter is only
-        # supported for `gpt-image-1`. Must be one of `png`, `jpeg`, or `webp`.
-        output_format: nil,
-        # The quality of the image that will be generated.
-        #
-        # - `auto` (default value) will automatically select the best quality for the
-        #   given model.
-        # - `high`, `medium` and `low` are supported for `gpt-image-1`.
-        # - `hd` and `standard` are supported for `dall-e-3`.
-        # - `standard` is the only option for `dall-e-2`.
-        quality: nil,
-        # The format in which generated images with `dall-e-2` and `dall-e-3` are
-        # returned. Must be one of `url` or `b64_json`. URLs are only valid for 60 minutes
-        # after the image has been generated. This parameter isn't supported for
-        # `gpt-image-1` which will always return base64-encoded images.
-        response_format: nil,
-        # The size of the generated images. Must be one of `1024x1024`, `1536x1024`
-        # (landscape), `1024x1536` (portrait), or `auto` (default value) for
-        # `gpt-image-1`, one of `256x256`, `512x512`, or `1024x1024` for `dall-e-2`, and
-        # one of `1024x1024`, `1792x1024`, or `1024x1792` for `dall-e-3`.
-        size: nil,
-        # The style of the generated images. This parameter is only supported for
-        # `dall-e-3`. Must be one of `vivid` or `natural`. Vivid causes the model to lean
-        # towards generating hyper-real and dramatic images. Natural causes the model to
-        # produce more natural, less hyper-real looking images.
-        style: nil,
-        # A unique identifier representing your end-user, which can help OpenAI to monitor
-        # and detect abuse.
-        # [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#end-user-ids).
-        user: nil,
-        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/models.rbi

@@ -1,52 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class Models
-      # Retrieves a model instance, providing basic information about the model such as
-      # the owner and permissioning.
-      sig do
-        params(
-          model: String,
-          request_options: OpenAI::RequestOptions::OrHash
-        ).returns(OpenAI::Model)
-      end
-      def retrieve(
-        # The ID of the model to use for this request
-        model,
-        request_options: {}
-      )
-      end
-
-      # Lists the currently available models, and provides basic information about each
-      # one such as the owner and availability.
-      sig do
-        params(request_options: OpenAI::RequestOptions::OrHash).returns(
-          OpenAI::Internal::Page[OpenAI::Model]
-        )
-      end
-      def list(request_options: {})
-      end
-
-      # Delete a fine-tuned model. You must have the Owner role in your organization to
-      # delete a model.
-      sig do
-        params(
-          model: String,
-          request_options: OpenAI::RequestOptions::OrHash
-        ).returns(OpenAI::ModelDeleted)
-      end
-      def delete(
-        # The model to delete
-        model,
-        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/moderations.rbi

@@ -1,34 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class Moderations
-      # Classifies if text and/or image inputs are potentially harmful. Learn more in
-      # the [moderation guide](https://platform.openai.com/docs/guides/moderation).
-      sig do
-        params(
-          input: OpenAI::ModerationCreateParams::Input::Variants,
-          model: T.any(String, OpenAI::ModerationModel::OrSymbol),
-          request_options: OpenAI::RequestOptions::OrHash
-        ).returns(OpenAI::Models::ModerationCreateResponse)
-      end
-      def create(
-        # Input (or inputs) to classify. Can be a single string, an array of strings, or
-        # an array of multi-modal input objects similar to other models.
-        input:,
-        # The content moderation model you would like to use. Learn more in
-        # [the moderation guide](https://platform.openai.com/docs/guides/moderation), and
-        # learn about available models
-        # [here](https://platform.openai.com/docs/models#moderation).
-        model: nil,
-        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/responses/input_items.rbi

@@ -1,52 +0,0 @@
-# typed: strong
-
-module OpenAI
-  module Resources
-    class Responses
-      class InputItems
-        # Returns a list of input items for a given response.
-        sig do
-          params(
-            response_id: String,
-            after: String,
-            before: String,
-            include: T::Array[OpenAI::Responses::ResponseIncludable::OrSymbol],
-            limit: Integer,
-            order: OpenAI::Responses::InputItemListParams::Order::OrSymbol,
-            request_options: OpenAI::RequestOptions::OrHash
-          ).returns(
-            OpenAI::Internal::CursorPage[
-              OpenAI::Responses::ResponseItem::Variants
-            ]
-          )
-        end
-        def list(
-          # The ID of the response to retrieve input items for.
-          response_id,
-          # An item ID to list items after, used in pagination.
-          after: nil,
-          # An item ID to list items before, used in pagination.
-          before: nil,
-          # Additional fields to include in the response. See the `include` parameter for
-          # Response creation above for more information.
-          include: 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,
-          # The order to return the input items in. Default is `desc`.
-          #
-          # - `asc`: Return the input items in ascending order.
-          # - `desc`: Return the input items in descending order.
-          order: nil,
-          request_options: {}
-        )
-        end
-
-        # @api private
-        sig { params(client: OpenAI::Client).returns(T.attached_class) }
-        def self.new(client:)
-        end
-      end
-    end
-  end
-end