openai 0.3.0 → 0.4.0.pre.beta.1

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

@@ -0,0 +1,214 @@
+# 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

@@ -0,0 +1,14 @@
+# 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

@@ -0,0 +1,24 @@
+# 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

@@ -0,0 +1,14 @@
+# 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

@@ -0,0 +1,15 @@
+# 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

@@ -0,0 +1,205 @@
+# 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

@@ -0,0 +1,52 @@
+# 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

@@ -0,0 +1,34 @@
+# 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

@@ -0,0 +1,52 @@
+# 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