openai 0.16.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78e829792412e459c6e623de5db5f553d7d1325fa28300ae94c62103d511c946
-  data.tar.gz: e7711af3f619a26ac688445353ee83b8ca250cad3feb84358f0a556650662e0b
+  metadata.gz: 6413e169f6a035774a4322aa42bbce1b9374344c1f68c5d452be6b0dffcd9756
+  data.tar.gz: 1ef928f4030023fd8a2076b08c3077f8ee7b9d95eef046eebbfc72004d46d327
 SHA512:
-  metadata.gz: 3a6d15ee5239db7f9f8fe2494169ce279c26435bc7b83a5b8ecb2dfde47da5f6636f6db49a29f429b7fca35b58d90136d06f7de4e49677ee37fb94b899f518da
-  data.tar.gz: 1f6659074cc6e2317b47e0677a928765d9d8b73e898f7c2ee0eb435dc1fa0728df18f64859a6a732ec3beaaa1db16a5e96176eb1bdda174ac9368cccd0a243a2
+  metadata.gz: cf5a3da338b678f1680b605d0cd5a383ca95d601706422e5bedd5131e7ee7d91f01941b7f913368cec2e007fc684309e64e449e52e724a3c7a764c993c3d9e53
+  data.tar.gz: ebb89edd3814ee447bcfababcb05662d26e7380fb024c943cb5fa30196fcc6c49aea64c820de4fe8256f2acdf20562544e41a410084d1e34c774cf179329dc47

data/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 0.17.0 (2025-08-08)
+
+Full Changelog: [v0.16.0...v0.17.0](https://github.com/openai/openai-ruby/compare/v0.16.0...v0.17.0)
+
+### Features
+
+* **api:** adds GPT-5 and new API features: platform.openai.com/docs/guides/gpt-5 ([068a381](https://github.com/openai/openai-ruby/commit/068a381a17dd2d60865e67fcd17fa84d919f3f5c))
+* **api:** manual updates ([1d79621](https://github.com/openai/openai-ruby/commit/1d79621120fbccc8dd41f5af6df5a9b1a9018e73))
+
+
+### Bug Fixes
+
+* **client:** dont try to parse if content is missing ([#770](https://github.com/openai/openai-ruby/issues/770)) ([7f8f2d3](https://github.com/openai/openai-ruby/commit/7f8f2d32863fafc39ee4a884937673a2ad9be358))
+* **client:** fix verbosity parameter location in Responses ([a6b7ae8](https://github.com/openai/openai-ruby/commit/a6b7ae8b568c2214d4883fad44c9cf2e8a7d53e2))
+* **internal:** fix rbi error ([803f20b](https://github.com/openai/openai-ruby/commit/803f20ba0c3751d28175dca99853783f0d851645))
+* **respones:** undo accidently deleted fields ([#177](https://github.com/openai/openai-ruby/issues/177)) ([90a7c3a](https://github.com/openai/openai-ruby/commit/90a7c3ac8d22cc90b8ecaa3b091598ea3bc73029))
+* **responses:** remove incorrect verbosity param ([127e2d1](https://github.com/openai/openai-ruby/commit/127e2d1b96b72307178446f0aa8acc1d3ad31367))
+
+
+### Chores
+
+* **internal:** increase visibility of internal helper method ([eddbcda](https://github.com/openai/openai-ruby/commit/eddbcda189ac0a864fc3dadc5dd3578d730c491f))
+* update @stainless-api/prism-cli to v5.15.0 ([aaa7d89](https://github.com/openai/openai-ruby/commit/aaa7d895a3dba31f32cf5f4373a49d1571667fc6))
+
 ## 0.16.0 (2025-07-30)
 
 Full Changelog: [v0.15.0...v0.16.0](https://github.com/openai/openai-ruby/compare/v0.15.0...v0.16.0)

data/README.md

@@ -15,7 +15,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "openai", "~> 0.16.0"
+gem "openai", "~> 0.17.0"
 ```
 
 <!-- x-release-please-end -->
@@ -30,10 +30,7 @@ openai = OpenAI::Client.new(
   api_key: ENV["OPENAI_API_KEY"] # This is the default and can be omitted
 )
 
-chat_completion = openai.chat.completions.create(
-  messages: [{role: "user", content: "Say this is a test"}],
-  model: :"gpt-4.1"
-)
+chat_completion = openai.chat.completions.create(messages: [{role: "user", content: "Say this is a test"}], model: :"gpt-5")
 
 puts(chat_completion)
 ```
@@ -45,7 +42,7 @@ We provide support for streaming responses using Server-Sent Events (SSE).
 ```ruby
 stream = openai.responses.stream(
   input: "Write a haiku about OpenAI.",
-  model: :"gpt-4.1"
+  model: :"gpt-5"
 )
 
 stream.each do |event|
@@ -343,7 +340,7 @@ openai = OpenAI::Client.new(
 # Or, configure per-request:
 openai.chat.completions.create(
   messages: [{role: "user", content: "How can I get the name of the current day in JavaScript?"}],
-  model: :"gpt-4.1",
+  model: :"gpt-5",
   request_options: {max_retries: 5}
 )
 ```
@@ -361,7 +358,7 @@ openai = OpenAI::Client.new(
 # Or, configure per-request:
 openai.chat.completions.create(
   messages: [{role: "user", content: "How can I list all files in a directory using Python?"}],
-  model: :"gpt-4.1",
+  model: :"gpt-5",
   request_options: {timeout: 5}
 )
 ```
@@ -396,7 +393,7 @@ Note: the `extra_` parameters of the same name overrides the documented paramete
 chat_completion =
   openai.chat.completions.create(
     messages: [{role: "user", content: "How can I get the name of the current day in JavaScript?"}],
-    model: :"gpt-4.1",
+    model: :"gpt-5",
     request_options: {
       extra_query: {my_query_parameter: value},
       extra_body: {my_body_parameter: value},
@@ -444,7 +441,7 @@ You can provide typesafe request parameters like so:
 ```ruby
 openai.chat.completions.create(
   messages: [OpenAI::Chat::ChatCompletionUserMessageParam.new(content: "Say this is a test")],
-  model: :"gpt-4.1"
+  model: :"gpt-5"
 )
 ```
 
@@ -452,15 +449,12 @@ Or, equivalently:
 
 ```ruby
 # Hashes work, but are not typesafe:
-openai.chat.completions.create(
-  messages: [{role: "user", content: "Say this is a test"}],
-  model: :"gpt-4.1"
-)
+openai.chat.completions.create(messages: [{role: "user", content: "Say this is a test"}], model: :"gpt-5")
 
 # You can also splat a full Params class:
 params = OpenAI::Chat::CompletionCreateParams.new(
   messages: [OpenAI::Chat::ChatCompletionUserMessageParam.new(content: "Say this is a test")],
-  model: :"gpt-4.1"
+  model: :"gpt-5"
 )
 openai.chat.completions.create(**params)
 ```
@@ -470,11 +464,11 @@ openai.chat.completions.create(**params)
 Since this library does not depend on `sorbet-runtime`, it cannot provide [`T::Enum`](https://sorbet.org/docs/tenum) instances. Instead, we provide "tagged symbols" instead, which is always a primitive at runtime:
 
 ```ruby
-# :low
-puts(OpenAI::ReasoningEffort::LOW)
+# :minimal
+puts(OpenAI::ReasoningEffort::MINIMAL)
 
 # Revealed type: `T.all(OpenAI::ReasoningEffort, Symbol)`
-T.reveal_type(OpenAI::ReasoningEffort::LOW)
+T.reveal_type(OpenAI::ReasoningEffort::MINIMAL)
 ```
 
 Enum parameters have a "relaxed" type, so you can either pass in enum constants or their literal value:
@@ -482,13 +476,13 @@ Enum parameters have a "relaxed" type, so you can either pass in enum constants
 ```ruby
 # Using the enum constants preserves the tagged type information:
 openai.chat.completions.create(
-  reasoning_effort: OpenAI::ReasoningEffort::LOW,
+  reasoning_effort: OpenAI::ReasoningEffort::MINIMAL,
   # …
 )
 
 # Literal values are also permissible:
 openai.chat.completions.create(
-  reasoning_effort: :low,
+  reasoning_effort: :minimal,
   # …
 )
 ```

data/lib/openai/internal/transport/base_client.rb

@@ -365,7 +365,7 @@ module OpenAI
         #
         # @raise [OpenAI::Errors::APIError]
         # @return [Array(Integer, Net::HTTPResponse, Enumerable<String>)]
-        private def send_request(request, redirect_count:, retry_count:, send_retry_header:)
+        def send_request(request, redirect_count:, retry_count:, send_retry_header:)
           url, headers, max_retries, timeout = request.fetch_values(:url, :headers, :max_retries, :timeout)
           input = {**request.except(:timeout), deadline: OpenAI::Internal::Util.monotonic_secs + timeout}
 

data/lib/openai/internal/type/enum.rb

@@ -19,11 +19,11 @@ module OpenAI
       # @example
       #   # `chat_model` is a `OpenAI::ChatModel`
       #   case chat_model
-      #   when OpenAI::ChatModel::GPT_4_1
+      #   when OpenAI::ChatModel::GPT_5
       #     # ...
-      #   when OpenAI::ChatModel::GPT_4_1_MINI
+      #   when OpenAI::ChatModel::GPT_5_MINI
       #     # ...
-      #   when OpenAI::ChatModel::GPT_4_1_NANO
+      #   when OpenAI::ChatModel::GPT_5_NANO
       #     # ...
       #   else
       #     puts(chat_model)
@@ -31,11 +31,11 @@ module OpenAI
       #
       # @example
       #   case chat_model
-      #   in :"gpt-4.1"
+      #   in :"gpt-5"
       #     # ...
-      #   in :"gpt-4.1-mini"
+      #   in :"gpt-5-mini"
       #     # ...
-      #   in :"gpt-4.1-nano"
+      #   in :"gpt-5-nano"
       #     # ...
       #   else
       #     puts(chat_model)

data/lib/openai/internal/type/union.rb

@@ -6,28 +6,24 @@ module OpenAI
       # @api private
       #
       # @example
-      #   # `chat_completion_content_part` is a `OpenAI::Chat::ChatCompletionContentPart`
-      #   case chat_completion_content_part
-      #   when OpenAI::Chat::ChatCompletionContentPartText
-      #     puts(chat_completion_content_part.text)
-      #   when OpenAI::Chat::ChatCompletionContentPartImage
-      #     puts(chat_completion_content_part.image_url)
-      #   when OpenAI::Chat::ChatCompletionContentPartInputAudio
-      #     puts(chat_completion_content_part.input_audio)
+      #   # `custom_tool_input_format` is a `OpenAI::CustomToolInputFormat`
+      #   case custom_tool_input_format
+      #   when OpenAI::CustomToolInputFormat::Text
+      #     puts(custom_tool_input_format.type)
+      #   when OpenAI::CustomToolInputFormat::Grammar
+      #     puts(custom_tool_input_format.definition)
       #   else
-      #     puts(chat_completion_content_part)
+      #     puts(custom_tool_input_format)
       #   end
       #
       # @example
-      #   case chat_completion_content_part
-      #   in {type: :text, text: text}
-      #     puts(text)
-      #   in {type: :image_url, image_url: image_url}
-      #     puts(image_url)
-      #   in {type: :input_audio, input_audio: input_audio}
-      #     puts(input_audio)
+      #   case custom_tool_input_format
+      #   in {type: :text}
+      #     # ...
+      #   in {type: :grammar, definition: definition, syntax: syntax}
+      #     puts(definition)
       #   else
-      #     puts(chat_completion_content_part)
+      #     puts(custom_tool_input_format)
       #   end
       module Union
         include OpenAI::Internal::Type::Converter

data/lib/openai/models/beta/assistant_create_params.rb

@@ -49,12 +49,11 @@ module OpenAI
         optional :name, String, nil?: true
 
         # @!attribute reasoning_effort
-        #   **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.
+        #   supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+        #   effort can result in faster responses and fewer tokens used on reasoning in a
+        #   response.
         #
         #   @return [Symbol, OpenAI::Models::ReasoningEffort, nil]
         optional :reasoning_effort, enum: -> { OpenAI::ReasoningEffort }, nil?: true
@@ -133,7 +132,7 @@ module OpenAI
         #
         #   @param name [String, nil] The name of the assistant. The maximum length is 256 characters.
         #
-        #   @param reasoning_effort [Symbol, OpenAI::Models::ReasoningEffort, nil] **o-series models only**
+        #   @param reasoning_effort [Symbol, OpenAI::Models::ReasoningEffort, nil] Constrains effort on reasoning for
         #
         #   @param response_format [Symbol, :auto, OpenAI::Models::ResponseFormatText, OpenAI::Models::ResponseFormatJSONObject, OpenAI::Models::ResponseFormatJSONSchema, nil] Specifies the format that the model must output. Compatible with [GPT-4o](https:
         #

data/lib/openai/models/beta/assistant_update_params.rb

@@ -49,12 +49,11 @@ module OpenAI
         optional :name, String, nil?: true
 
         # @!attribute reasoning_effort
-        #   **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.
+        #   supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+        #   effort can result in faster responses and fewer tokens used on reasoning in a
+        #   response.
         #
         #   @return [Symbol, OpenAI::Models::ReasoningEffort, nil]
         optional :reasoning_effort, enum: -> { OpenAI::ReasoningEffort }, nil?: true
@@ -133,7 +132,7 @@ module OpenAI
         #
         #   @param name [String, nil] The name of the assistant. The maximum length is 256 characters.
         #
-        #   @param reasoning_effort [Symbol, OpenAI::Models::ReasoningEffort, nil] **o-series models only**
+        #   @param reasoning_effort [Symbol, OpenAI::Models::ReasoningEffort, nil] Constrains effort on reasoning for
         #
         #   @param response_format [Symbol, :auto, OpenAI::Models::ResponseFormatText, OpenAI::Models::ResponseFormatJSONObject, OpenAI::Models::ResponseFormatJSONSchema, nil] Specifies the format that the model must output. Compatible with [GPT-4o](https:
         #
@@ -157,6 +156,18 @@ module OpenAI
 
           variant String
 
+          variant const: -> { OpenAI::Models::Beta::AssistantUpdateParams::Model::GPT_5 }
+
+          variant const: -> { OpenAI::Models::Beta::AssistantUpdateParams::Model::GPT_5_MINI }
+
+          variant const: -> { OpenAI::Models::Beta::AssistantUpdateParams::Model::GPT_5_NANO }
+
+          variant const: -> { OpenAI::Models::Beta::AssistantUpdateParams::Model::GPT_5_2025_08_07 }
+
+          variant const: -> { OpenAI::Models::Beta::AssistantUpdateParams::Model::GPT_5_MINI_2025_08_07 }
+
+          variant const: -> { OpenAI::Models::Beta::AssistantUpdateParams::Model::GPT_5_NANO_2025_08_07 }
+
           variant const: -> { OpenAI::Models::Beta::AssistantUpdateParams::Model::GPT_4_1 }
 
           variant const: -> { OpenAI::Models::Beta::AssistantUpdateParams::Model::GPT_4_1_MINI }
@@ -238,6 +249,12 @@ module OpenAI
 
           # @!group
 
+          GPT_5 = :"gpt-5"
+          GPT_5_MINI = :"gpt-5-mini"
+          GPT_5_NANO = :"gpt-5-nano"
+          GPT_5_2025_08_07 = :"gpt-5-2025-08-07"
+          GPT_5_MINI_2025_08_07 = :"gpt-5-mini-2025-08-07"
+          GPT_5_NANO_2025_08_07 = :"gpt-5-nano-2025-08-07"
           GPT_4_1 = :"gpt-4.1"
           GPT_4_1_MINI = :"gpt-4.1-mini"
           GPT_4_1_NANO = :"gpt-4.1-nano"

data/lib/openai/models/beta/threads/run_create_params.rb

@@ -107,12 +107,11 @@ module OpenAI
           optional :parallel_tool_calls, OpenAI::Internal::Type::Boolean
 
           # @!attribute reasoning_effort
-          #   **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.
+          #   supported values are `minimal`, `low`, `medium`, and `high`. Reducing reasoning
+          #   effort can result in faster responses and fewer tokens used on reasoning in a
+          #   response.
           #
           #   @return [Symbol, OpenAI::Models::ReasoningEffort, nil]
           optional :reasoning_effort, enum: -> { OpenAI::ReasoningEffort }, nil?: true
@@ -216,7 +215,7 @@ module OpenAI
           #
           #   @param parallel_tool_calls [Boolean] Whether to enable [parallel function calling](https://platform.openai.com/docs/g
           #
-          #   @param reasoning_effort [Symbol, OpenAI::Models::ReasoningEffort, nil] **o-series models only**
+          #   @param reasoning_effort [Symbol, OpenAI::Models::ReasoningEffort, nil] Constrains effort on reasoning for
           #
           #   @param response_format [Symbol, :auto, OpenAI::Models::ResponseFormatText, OpenAI::Models::ResponseFormatJSONObject, OpenAI::Models::ResponseFormatJSONSchema, nil] Specifies the format that the model must output. Compatible with [GPT-4o](https:
           #

data/lib/openai/models/chat/chat_completion_allowed_tool_choice.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Chat
+      class ChatCompletionAllowedToolChoice < OpenAI::Internal::Type::BaseModel
+        # @!attribute allowed_tools
+        #   Constrains the tools available to the model to a pre-defined set.
+        #
+        #   @return [OpenAI::Models::Chat::ChatCompletionAllowedTools]
+        required :allowed_tools, -> { OpenAI::Chat::ChatCompletionAllowedTools }
+
+        # @!attribute type
+        #   Allowed tool configuration type. Always `allowed_tools`.
+        #
+        #   @return [Symbol, :allowed_tools]
+        required :type, const: :allowed_tools
+
+        # @!method initialize(allowed_tools:, type: :allowed_tools)
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Chat::ChatCompletionAllowedToolChoice} for more details.
+        #
+        #   Constrains the tools available to the model to a pre-defined set.
+        #
+        #   @param allowed_tools [OpenAI::Models::Chat::ChatCompletionAllowedTools] Constrains the tools available to the model to a pre-defined set.
+        #
+        #   @param type [Symbol, :allowed_tools] Allowed tool configuration type. Always `allowed_tools`.
+      end
+    end
+
+    ChatCompletionAllowedToolChoice = Chat::ChatCompletionAllowedToolChoice
+  end
+end

data/lib/openai/models/chat/chat_completion_allowed_tools.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Chat
+      class ChatCompletionAllowedTools < OpenAI::Internal::Type::BaseModel
+        # @!attribute mode
+        #   Constrains the tools available to the model to a pre-defined set.
+        #
+        #   `auto` allows the model to pick from among the allowed tools and generate a
+        #   message.
+        #
+        #   `required` requires the model to call one or more of the allowed tools.
+        #
+        #   @return [Symbol, OpenAI::Models::Chat::ChatCompletionAllowedTools::Mode]
+        required :mode, enum: -> { OpenAI::Chat::ChatCompletionAllowedTools::Mode }
+
+        # @!attribute tools
+        #   A list of tool definitions that the model should be allowed to call.
+        #
+        #   For the Chat Completions API, the list of tool definitions might look like:
+        #
+        #   ```json
+        #   [
+        #     { "type": "function", "function": { "name": "get_weather" } },
+        #     { "type": "function", "function": { "name": "get_time" } }
+        #   ]
+        #   ```
+        #
+        #   @return [Array<Hash{Symbol=>Object}>]
+        required :tools,
+                 OpenAI::Internal::Type::ArrayOf[OpenAI::Internal::Type::HashOf[OpenAI::Internal::Type::Unknown]]
+
+        # @!method initialize(mode:, tools:)
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Chat::ChatCompletionAllowedTools} for more details.
+        #
+        #   Constrains the tools available to the model to a pre-defined set.
+        #
+        #   @param mode [Symbol, OpenAI::Models::Chat::ChatCompletionAllowedTools::Mode] Constrains the tools available to the model to a pre-defined set.
+        #
+        #   @param tools [Array<Hash{Symbol=>Object}>] A list of tool definitions that the model should be allowed to call.
+
+        # Constrains the tools available to the model to a pre-defined set.
+        #
+        # `auto` allows the model to pick from among the allowed tools and generate a
+        # message.
+        #
+        # `required` requires the model to call one or more of the allowed tools.
+        #
+        # @see OpenAI::Models::Chat::ChatCompletionAllowedTools#mode
+        module Mode
+          extend OpenAI::Internal::Type::Enum
+
+          AUTO = :auto
+          REQUIRED = :required
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+      end
+    end
+  end
+end

data/lib/openai/models/chat/chat_completion_assistant_message_param.rb

@@ -55,11 +55,9 @@ module OpenAI
         # @!attribute tool_calls
         #   The tool calls generated by the model, such as function calls.
         #
-        #   @return [Array<OpenAI::Models::Chat::ChatCompletionMessageToolCall>, nil]
+        #   @return [Array<OpenAI::Models::Chat::ChatCompletionMessageFunctionToolCall, OpenAI::Models::Chat::ChatCompletionMessageCustomToolCall>, nil]
         optional :tool_calls,
-                 -> {
-                   OpenAI::Internal::Type::ArrayOf[OpenAI::Chat::ChatCompletionMessageToolCall]
-                 }
+                 -> { OpenAI::Internal::Type::ArrayOf[union: OpenAI::Chat::ChatCompletionMessageToolCall] }
 
         # @!method initialize(audio: nil, content: nil, function_call: nil, name: nil, refusal: nil, tool_calls: nil, role: :assistant)
         #   Some parameter documentations has been truncated, see
@@ -77,7 +75,7 @@ module OpenAI
         #
         #   @param refusal [String, nil] The refusal message by the assistant.
         #
-        #   @param tool_calls [Array<OpenAI::Models::Chat::ChatCompletionMessageToolCall>] The tool calls generated by the model, such as function calls.
+        #   @param tool_calls [Array<OpenAI::Models::Chat::ChatCompletionMessageFunctionToolCall, OpenAI::Models::Chat::ChatCompletionMessageCustomToolCall>] The tool calls generated by the model, such as function calls.
         #
         #   @param role [Symbol, :assistant] The role of the messages author, in this case `assistant`.
 

data/lib/openai/models/chat/chat_completion_custom_tool.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Chat
+      class ChatCompletionCustomTool < OpenAI::Internal::Type::BaseModel
+        # @!attribute custom
+        #   Properties of the custom tool.
+        #
+        #   @return [OpenAI::Models::Chat::ChatCompletionCustomTool::Custom]
+        required :custom, -> { OpenAI::Chat::ChatCompletionCustomTool::Custom }
+
+        # @!attribute type
+        #   The type of the custom tool. Always `custom`.
+        #
+        #   @return [Symbol, :custom]
+        required :type, const: :custom
+
+        # @!method initialize(custom:, type: :custom)
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Chat::ChatCompletionCustomTool} for more details.
+        #
+        #   A custom tool that processes input using a specified format.
+        #
+        #   @param custom [OpenAI::Models::Chat::ChatCompletionCustomTool::Custom] Properties of the custom tool.
+        #
+        #   @param type [Symbol, :custom] The type of the custom tool. Always `custom`.
+
+        # @see OpenAI::Models::Chat::ChatCompletionCustomTool#custom
+        class Custom < OpenAI::Internal::Type::BaseModel
+          # @!attribute name
+          #   The name of the custom tool, used to identify it in tool calls.
+          #
+          #   @return [String]
+          required :name, String
+
+          # @!attribute description
+          #   Optional description of the custom tool, used to provide more context.
+          #
+          #   @return [String, nil]
+          optional :description, String
+
+          # @!attribute format_
+          #   The input format for the custom tool. Default is unconstrained text.
+          #
+          #   @return [OpenAI::Models::Chat::ChatCompletionCustomTool::Custom::Format::Text, OpenAI::Models::Chat::ChatCompletionCustomTool::Custom::Format::Grammar, nil]
+          optional :format_,
+                   union: -> {
+                     OpenAI::Chat::ChatCompletionCustomTool::Custom::Format
+                   },
+                   api_name: :format
+
+          # @!method initialize(name:, description: nil, format_: nil)
+          #   Some parameter documentations has been truncated, see
+          #   {OpenAI::Models::Chat::ChatCompletionCustomTool::Custom} for more details.
+          #
+          #   Properties of the custom tool.
+          #
+          #   @param name [String] The name of the custom tool, used to identify it in tool calls.
+          #
+          #   @param description [String] Optional description of the custom tool, used to provide more context.
+          #
+          #   @param format_ [OpenAI::Models::Chat::ChatCompletionCustomTool::Custom::Format::Text, OpenAI::Models::Chat::ChatCompletionCustomTool::Custom::Format::Grammar] The input format for the custom tool. Default is unconstrained text.
+
+          # The input format for the custom tool. Default is unconstrained text.
+          #
+          # @see OpenAI::Models::Chat::ChatCompletionCustomTool::Custom#format_
+          module Format
+            extend OpenAI::Internal::Type::Union
+
+            discriminator :type
+
+            # Unconstrained free-form text.
+            variant :text, -> { OpenAI::Chat::ChatCompletionCustomTool::Custom::Format::Text }
+
+            # A grammar defined by the user.
+            variant :grammar, -> { OpenAI::Chat::ChatCompletionCustomTool::Custom::Format::Grammar }
+
+            class Text < OpenAI::Internal::Type::BaseModel
+              # @!attribute type
+              #   Unconstrained text format. Always `text`.
+              #
+              #   @return [Symbol, :text]
+              required :type, const: :text
+
+              # @!method initialize(type: :text)
+              #   Unconstrained free-form text.
+              #
+              #   @param type [Symbol, :text] Unconstrained text format. Always `text`.
+            end
+
+            class Grammar < OpenAI::Internal::Type::BaseModel
+              # @!attribute grammar
+              #   Your chosen grammar.
+              #
+              #   @return [OpenAI::Models::Chat::ChatCompletionCustomTool::Custom::Format::Grammar::Grammar]
+              required :grammar,
+                       -> {
+                         OpenAI::Chat::ChatCompletionCustomTool::Custom::Format::Grammar::Grammar
+                       }
+
+              # @!attribute type
+              #   Grammar format. Always `grammar`.
+              #
+              #   @return [Symbol, :grammar]
+              required :type, const: :grammar
+
+              # @!method initialize(grammar:, type: :grammar)
+              #   A grammar defined by the user.
+              #
+              #   @param grammar [OpenAI::Models::Chat::ChatCompletionCustomTool::Custom::Format::Grammar::Grammar] Your chosen grammar.
+              #
+              #   @param type [Symbol, :grammar] Grammar format. Always `grammar`.
+
+              # @see OpenAI::Models::Chat::ChatCompletionCustomTool::Custom::Format::Grammar#grammar
+              class Grammar < OpenAI::Internal::Type::BaseModel
+                # @!attribute definition
+                #   The grammar definition.
+                #
+                #   @return [String]
+                required :definition, String
+
+                # @!attribute syntax
+                #   The syntax of the grammar definition. One of `lark` or `regex`.
+                #
+                #   @return [Symbol, OpenAI::Models::Chat::ChatCompletionCustomTool::Custom::Format::Grammar::Grammar::Syntax]
+                required :syntax,
+                         enum: -> {
+                           OpenAI::Chat::ChatCompletionCustomTool::Custom::Format::Grammar::Grammar::Syntax
+                         }
+
+                # @!method initialize(definition:, syntax:)
+                #   Your chosen grammar.
+                #
+                #   @param definition [String] The grammar definition.
+                #
+                #   @param syntax [Symbol, OpenAI::Models::Chat::ChatCompletionCustomTool::Custom::Format::Grammar::Grammar::Syntax] The syntax of the grammar definition. One of `lark` or `regex`.
+
+                # The syntax of the grammar definition. One of `lark` or `regex`.
+                #
+                # @see OpenAI::Models::Chat::ChatCompletionCustomTool::Custom::Format::Grammar::Grammar#syntax
+                module Syntax
+                  extend OpenAI::Internal::Type::Enum
+
+                  LARK = :lark
+                  REGEX = :regex
+
+                  # @!method self.values
+                  #   @return [Array<Symbol>]
+                end
+              end
+            end
+
+            # @!method self.variants
+            #   @return [Array(OpenAI::Models::Chat::ChatCompletionCustomTool::Custom::Format::Text, OpenAI::Models::Chat::ChatCompletionCustomTool::Custom::Format::Grammar)]
+          end
+        end
+      end
+    end
+
+    ChatCompletionCustomTool = Chat::ChatCompletionCustomTool
+  end
+end

data/lib/openai/models/chat/chat_completion_function_tool.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Chat
+      class ChatCompletionFunctionTool < OpenAI::Internal::Type::BaseModel
+        # @!attribute function
+        #
+        #   @return [OpenAI::Models::FunctionDefinition]
+        required :function, -> { OpenAI::FunctionDefinition }
+
+        # @!attribute type
+        #   The type of the tool. Currently, only `function` is supported.
+        #
+        #   @return [Symbol, :function]
+        required :type, const: :function
+
+        # @!method initialize(function:, type: :function)
+        #   A function tool that can be used to generate a response.
+        #
+        #   @param function [OpenAI::Models::FunctionDefinition]
+        #
+        #   @param type [Symbol, :function] The type of the tool. Currently, only `function` is supported.
+      end
+    end
+
+    ChatCompletionFunctionTool = Chat::ChatCompletionFunctionTool
+  end
+end