openai 0.6.0 → 0.7.0

data/lib/openai/models/evals/run_retrieve_response.rb

@@ -620,20 +620,96 @@ module OpenAI
               #   @return [Float, nil]
               optional :temperature, Float
 
+              # @!attribute text
+              #   Configuration options for a text response from the model. Can be plain text or
+              #   structured JSON data. Learn more:
+              #
+              #   - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+              #   - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+              #
+              #   @return [OpenAI::Models::Evals::RunRetrieveResponse::DataSource::Responses::SamplingParams::Text, nil]
+              optional :text,
+                       -> { OpenAI::Models::Evals::RunRetrieveResponse::DataSource::Responses::SamplingParams::Text }
+
+              # @!attribute tools
+              #   An array of tools the model may call while generating a response. You can
+              #   specify which tool to use by setting the `tool_choice` parameter.
+              #
+              #   The two categories of tools you can provide the model are:
+              #
+              #   - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
+              #     capabilities, like
+              #     [web search](https://platform.openai.com/docs/guides/tools-web-search) or
+              #     [file search](https://platform.openai.com/docs/guides/tools-file-search).
+              #     Learn more about
+              #     [built-in tools](https://platform.openai.com/docs/guides/tools).
+              #   - **Function calls (custom tools)**: Functions that are defined by you, enabling
+              #     the model to call your own code. Learn more about
+              #     [function calling](https://platform.openai.com/docs/guides/function-calling).
+              #
+              #   @return [Array<OpenAI::Models::Responses::FunctionTool, OpenAI::Models::Responses::FileSearchTool, OpenAI::Models::Responses::ComputerTool, OpenAI::Models::Responses::Tool::Mcp, OpenAI::Models::Responses::Tool::CodeInterpreter, OpenAI::Models::Responses::Tool::ImageGeneration, OpenAI::Models::Responses::Tool::LocalShell, OpenAI::Models::Responses::WebSearchTool>, nil]
+              optional :tools, -> { OpenAI::Internal::Type::ArrayOf[union: OpenAI::Responses::Tool] }
+
               # @!attribute top_p
               #   An alternative to temperature for nucleus sampling; 1.0 includes all tokens.
               #
               #   @return [Float, nil]
               optional :top_p, Float
 
-              # @!method initialize(max_completion_tokens: nil, seed: nil, temperature: nil, top_p: nil)
+              # @!method initialize(max_completion_tokens: nil, seed: nil, temperature: nil, text: nil, tools: nil, top_p: nil)
+              #   Some parameter documentations has been truncated, see
+              #   {OpenAI::Models::Evals::RunRetrieveResponse::DataSource::Responses::SamplingParams}
+              #   for more details.
+              #
               #   @param max_completion_tokens [Integer] The maximum number of tokens in the generated output.
               #
               #   @param seed [Integer] A seed value to initialize the randomness, during sampling.
               #
               #   @param temperature [Float] A higher temperature increases randomness in the outputs.
               #
+              #   @param text [OpenAI::Models::Evals::RunRetrieveResponse::DataSource::Responses::SamplingParams::Text] Configuration options for a text response from the model. Can be plain
+              #
+              #   @param tools [Array<OpenAI::Models::Responses::FunctionTool, OpenAI::Models::Responses::FileSearchTool, OpenAI::Models::Responses::ComputerTool, OpenAI::Models::Responses::Tool::Mcp, OpenAI::Models::Responses::Tool::CodeInterpreter, OpenAI::Models::Responses::Tool::ImageGeneration, OpenAI::Models::Responses::Tool::LocalShell, OpenAI::Models::Responses::WebSearchTool>] An array of tools the model may call while generating a response. You
+              #
               #   @param top_p [Float] An alternative to temperature for nucleus sampling; 1.0 includes all tokens.
+
+              # @see OpenAI::Models::Evals::RunRetrieveResponse::DataSource::Responses::SamplingParams#text
+              class Text < OpenAI::Internal::Type::BaseModel
+                # @!attribute format_
+                #   An object specifying the format that the model must output.
+                #
+                #   Configuring `{ "type": "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).
+                #
+                #   The default format is `{ "type": "text" }` with no additional options.
+                #
+                #   **Not recommended for gpt-4o and newer models:**
+                #
+                #   Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+                #   ensures the message the model generates is valid JSON. Using `json_schema` is
+                #   preferred for models that support it.
+                #
+                #   @return [OpenAI::Models::ResponseFormatText, OpenAI::Models::Responses::ResponseFormatTextJSONSchemaConfig, OpenAI::Models::ResponseFormatJSONObject, nil]
+                optional :format_,
+                         union: -> {
+                           OpenAI::Responses::ResponseFormatTextConfig
+                         },
+                         api_name: :format
+
+                # @!method initialize(format_: nil)
+                #   Some parameter documentations has been truncated, see
+                #   {OpenAI::Models::Evals::RunRetrieveResponse::DataSource::Responses::SamplingParams::Text}
+                #   for more details.
+                #
+                #   Configuration options for a text response from the model. Can be plain text or
+                #   structured JSON data. Learn more:
+                #
+                #   - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+                #   - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+                #
+                #   @param format_ [OpenAI::Models::ResponseFormatText, OpenAI::Models::Responses::ResponseFormatTextJSONSchemaConfig, OpenAI::Models::ResponseFormatJSONObject] An object specifying the format that the model must output.
+              end
             end
           end
 

data/lib/openai/resources/chat/completions.rb

@@ -140,7 +140,9 @@ module OpenAI
                 name = func[:name] ||= params.name.split("::").last
                 tool_models.store(name, params)
                 func.update(parameters: params.to_json_schema)
+                tool
               else
+                tool
               end
             end
             tools.replace(mapped)

data/lib/openai/resources/responses.rb

@@ -117,7 +117,9 @@ module OpenAI
               name = func[:name] ||= params.name.split("::").last
               tool_models.store(name, params)
               func.update(parameters: params.to_json_schema)
+              tool
             else
+              tool
             end
           end
           tools.replace(mapped)

data/lib/openai/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OpenAI
-  VERSION = "0.6.0"
+  VERSION = "0.7.0"
 end

data/rbi/openai/internal/util.rbi

@@ -332,6 +332,8 @@ module OpenAI
         end
 
         # @api private
+        #
+        # https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#special-considerations-for-multipart-content
         sig do
           params(body: T.anything).returns([String, T::Enumerable[String]])
         end

data/rbi/openai/models/evals/create_eval_completions_run_data_source.rbi

@@ -814,6 +814,41 @@ module OpenAI
           sig { params(max_completion_tokens: Integer).void }
           attr_writer :max_completion_tokens
 
+          # An object specifying the format that the model must output.
+          #
+          # 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 the older JSON mode, which
+          # ensures the message the model generates is valid JSON. Using `json_schema` is
+          # preferred for models that support it.
+          sig do
+            returns(
+              T.nilable(
+                T.any(
+                  OpenAI::ResponseFormatText,
+                  OpenAI::ResponseFormatJSONSchema,
+                  OpenAI::ResponseFormatJSONObject
+                )
+              )
+            )
+          end
+          attr_reader :response_format
+
+          sig do
+            params(
+              response_format:
+                T.any(
+                  OpenAI::ResponseFormatText::OrHash,
+                  OpenAI::ResponseFormatJSONSchema::OrHash,
+                  OpenAI::ResponseFormatJSONObject::OrHash
+                )
+            ).void
+          end
+          attr_writer :response_format
+
           # A seed value to initialize the randomness, during sampling.
           sig { returns(T.nilable(Integer)) }
           attr_reader :seed
@@ -828,6 +863,19 @@ module OpenAI
           sig { params(temperature: Float).void }
           attr_writer :temperature
 
+          # A list of tools the model may call. Currently, only functions are supported as a
+          # tool. Use this to provide a list of functions the model may generate JSON inputs
+          # for. A max of 128 functions are supported.
+          sig { returns(T.nilable(T::Array[OpenAI::Chat::ChatCompletionTool])) }
+          attr_reader :tools
+
+          sig do
+            params(
+              tools: T::Array[OpenAI::Chat::ChatCompletionTool::OrHash]
+            ).void
+          end
+          attr_writer :tools
+
           # An alternative to temperature for nucleus sampling; 1.0 includes all tokens.
           sig { returns(T.nilable(Float)) }
           attr_reader :top_p
@@ -838,18 +886,40 @@ module OpenAI
           sig do
             params(
               max_completion_tokens: Integer,
+              response_format:
+                T.any(
+                  OpenAI::ResponseFormatText::OrHash,
+                  OpenAI::ResponseFormatJSONSchema::OrHash,
+                  OpenAI::ResponseFormatJSONObject::OrHash
+                ),
               seed: Integer,
               temperature: Float,
+              tools: T::Array[OpenAI::Chat::ChatCompletionTool::OrHash],
               top_p: Float
             ).returns(T.attached_class)
           end
           def self.new(
             # The maximum number of tokens in the generated output.
             max_completion_tokens: nil,
+            # An object specifying the format that the model must output.
+            #
+            # 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 the older JSON mode, which
+            # ensures the message the model generates is valid JSON. Using `json_schema` is
+            # preferred for models that support it.
+            response_format: nil,
             # A seed value to initialize the randomness, during sampling.
             seed: nil,
             # A higher temperature increases randomness in the outputs.
             temperature: nil,
+            # A list of tools the model may call. Currently, only functions are supported as a
+            # tool. Use this to provide a list of functions the model may generate JSON inputs
+            # for. A max of 128 functions are supported.
+            tools: nil,
             # An alternative to temperature for nucleus sampling; 1.0 includes all tokens.
             top_p: nil
           )
@@ -859,14 +929,54 @@ module OpenAI
             override.returns(
               {
                 max_completion_tokens: Integer,
+                response_format:
+                  T.any(
+                    OpenAI::ResponseFormatText,
+                    OpenAI::ResponseFormatJSONSchema,
+                    OpenAI::ResponseFormatJSONObject
+                  ),
                 seed: Integer,
                 temperature: Float,
+                tools: T::Array[OpenAI::Chat::ChatCompletionTool],
                 top_p: Float
               }
             )
           end
           def to_hash
           end
+
+          # An object specifying the format that the model must output.
+          #
+          # 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 the older JSON mode, which
+          # ensures the message the model generates is valid JSON. Using `json_schema` is
+          # preferred for models that support it.
+          module ResponseFormat
+            extend OpenAI::Internal::Type::Union
+
+            Variants =
+              T.type_alias do
+                T.any(
+                  OpenAI::ResponseFormatText,
+                  OpenAI::ResponseFormatJSONSchema,
+                  OpenAI::ResponseFormatJSONObject
+                )
+              end
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Evals::CreateEvalCompletionsRunDataSource::SamplingParams::ResponseFormat::Variants
+                ]
+              )
+            end
+            def self.variants
+            end
+          end
         end
       end
     end

data/rbi/openai/models/evals/run_cancel_response.rbi

@@ -1056,6 +1056,66 @@ module OpenAI
               sig { params(temperature: Float).void }
               attr_writer :temperature
 
+              # Configuration options for a text response from the model. Can be plain text or
+              # structured JSON data. Learn more:
+              #
+              # - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+              # - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+              sig do
+                returns(
+                  T.nilable(
+                    OpenAI::Models::Evals::RunCancelResponse::DataSource::Responses::SamplingParams::Text
+                  )
+                )
+              end
+              attr_reader :text
+
+              sig do
+                params(
+                  text:
+                    OpenAI::Models::Evals::RunCancelResponse::DataSource::Responses::SamplingParams::Text::OrHash
+                ).void
+              end
+              attr_writer :text
+
+              # An array of tools the model may call while generating a response. You can
+              # specify which tool to use by setting the `tool_choice` parameter.
+              #
+              # The two categories of tools you can provide the model are:
+              #
+              # - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
+              #   capabilities, like
+              #   [web search](https://platform.openai.com/docs/guides/tools-web-search) or
+              #   [file search](https://platform.openai.com/docs/guides/tools-file-search).
+              #   Learn more about
+              #   [built-in tools](https://platform.openai.com/docs/guides/tools).
+              # - **Function calls (custom tools)**: Functions that are defined by you, enabling
+              #   the model to call your own code. Learn more about
+              #   [function calling](https://platform.openai.com/docs/guides/function-calling).
+              sig do
+                returns(T.nilable(T::Array[OpenAI::Responses::Tool::Variants]))
+              end
+              attr_reader :tools
+
+              sig do
+                params(
+                  tools:
+                    T::Array[
+                      T.any(
+                        OpenAI::Responses::FunctionTool::OrHash,
+                        OpenAI::Responses::FileSearchTool::OrHash,
+                        OpenAI::Responses::ComputerTool::OrHash,
+                        OpenAI::Responses::Tool::Mcp::OrHash,
+                        OpenAI::Responses::Tool::CodeInterpreter::OrHash,
+                        OpenAI::Responses::Tool::ImageGeneration::OrHash,
+                        OpenAI::Responses::Tool::LocalShell::OrHash,
+                        OpenAI::Responses::WebSearchTool::OrHash
+                      )
+                    ]
+                ).void
+              end
+              attr_writer :tools
+
               # An alternative to temperature for nucleus sampling; 1.0 includes all tokens.
               sig { returns(T.nilable(Float)) }
               attr_reader :top_p
@@ -1068,6 +1128,21 @@ module OpenAI
                   max_completion_tokens: Integer,
                   seed: Integer,
                   temperature: Float,
+                  text:
+                    OpenAI::Models::Evals::RunCancelResponse::DataSource::Responses::SamplingParams::Text::OrHash,
+                  tools:
+                    T::Array[
+                      T.any(
+                        OpenAI::Responses::FunctionTool::OrHash,
+                        OpenAI::Responses::FileSearchTool::OrHash,
+                        OpenAI::Responses::ComputerTool::OrHash,
+                        OpenAI::Responses::Tool::Mcp::OrHash,
+                        OpenAI::Responses::Tool::CodeInterpreter::OrHash,
+                        OpenAI::Responses::Tool::ImageGeneration::OrHash,
+                        OpenAI::Responses::Tool::LocalShell::OrHash,
+                        OpenAI::Responses::WebSearchTool::OrHash
+                      )
+                    ],
                   top_p: Float
                 ).returns(T.attached_class)
               end
@@ -1078,6 +1153,27 @@ module OpenAI
                 seed: nil,
                 # A higher temperature increases randomness in the outputs.
                 temperature: nil,
+                # Configuration options for a text response from the model. Can be plain text or
+                # structured JSON data. Learn more:
+                #
+                # - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+                # - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+                text: nil,
+                # An array of tools the model may call while generating a response. You can
+                # specify which tool to use by setting the `tool_choice` parameter.
+                #
+                # The two categories of tools you can provide the model are:
+                #
+                # - **Built-in tools**: Tools that are provided by OpenAI that extend the model's
+                #   capabilities, like
+                #   [web search](https://platform.openai.com/docs/guides/tools-web-search) or
+                #   [file search](https://platform.openai.com/docs/guides/tools-file-search).
+                #   Learn more about
+                #   [built-in tools](https://platform.openai.com/docs/guides/tools).
+                # - **Function calls (custom tools)**: Functions that are defined by you, enabling
+                #   the model to call your own code. Learn more about
+                #   [function calling](https://platform.openai.com/docs/guides/function-calling).
+                tools: nil,
                 # An alternative to temperature for nucleus sampling; 1.0 includes all tokens.
                 top_p: nil
               )
@@ -1089,12 +1185,103 @@ module OpenAI
                     max_completion_tokens: Integer,
                     seed: Integer,
                     temperature: Float,
+                    text:
+                      OpenAI::Models::Evals::RunCancelResponse::DataSource::Responses::SamplingParams::Text,
+                    tools: T::Array[OpenAI::Responses::Tool::Variants],
                     top_p: Float
                   }
                 )
               end
               def to_hash
               end
+
+              class Text < OpenAI::Internal::Type::BaseModel
+                OrHash =
+                  T.type_alias do
+                    T.any(
+                      OpenAI::Models::Evals::RunCancelResponse::DataSource::Responses::SamplingParams::Text,
+                      OpenAI::Internal::AnyHash
+                    )
+                  end
+
+                # An object specifying the format that the model must output.
+                #
+                # Configuring `{ "type": "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).
+                #
+                # The default format is `{ "type": "text" }` with no additional options.
+                #
+                # **Not recommended for gpt-4o and newer models:**
+                #
+                # Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+                # ensures the message the model generates is valid JSON. Using `json_schema` is
+                # preferred for models that support it.
+                sig do
+                  returns(
+                    T.nilable(
+                      OpenAI::Responses::ResponseFormatTextConfig::Variants
+                    )
+                  )
+                end
+                attr_reader :format_
+
+                sig do
+                  params(
+                    format_:
+                      T.any(
+                        OpenAI::ResponseFormatText::OrHash,
+                        OpenAI::Responses::ResponseFormatTextJSONSchemaConfig::OrHash,
+                        OpenAI::ResponseFormatJSONObject::OrHash
+                      )
+                  ).void
+                end
+                attr_writer :format_
+
+                # Configuration options for a text response from the model. Can be plain text or
+                # structured JSON data. Learn more:
+                #
+                # - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
+                # - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
+                sig do
+                  params(
+                    format_:
+                      T.any(
+                        OpenAI::ResponseFormatText::OrHash,
+                        OpenAI::Responses::ResponseFormatTextJSONSchemaConfig::OrHash,
+                        OpenAI::ResponseFormatJSONObject::OrHash
+                      )
+                  ).returns(T.attached_class)
+                end
+                def self.new(
+                  # An object specifying the format that the model must output.
+                  #
+                  # Configuring `{ "type": "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).
+                  #
+                  # The default format is `{ "type": "text" }` with no additional options.
+                  #
+                  # **Not recommended for gpt-4o and newer models:**
+                  #
+                  # Setting to `{ "type": "json_object" }` enables the older JSON mode, which
+                  # ensures the message the model generates is valid JSON. Using `json_schema` is
+                  # preferred for models that support it.
+                  format_: nil
+                )
+                end
+
+                sig do
+                  override.returns(
+                    {
+                      format_:
+                        OpenAI::Responses::ResponseFormatTextConfig::Variants
+                    }
+                  )
+                end
+                def to_hash
+                end
+              end
             end
           end