openai 0.15.0 → 0.17.0

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

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

@@ -56,11 +56,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(content:, refusal:, annotations: nil, audio: nil, function_call: nil, tool_calls: nil, role: :assistant)
         #   Some parameter documentations has been truncated, see
@@ -78,7 +76,7 @@ module OpenAI
         #
         #   @param function_call [OpenAI::Models::Chat::ChatCompletionMessage::FunctionCall] Deprecated and replaced by `tool_calls`. The name and arguments of a function th
         #
-        #   @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 author of this message.
 

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Chat
+      class ChatCompletionMessageCustomToolCall < OpenAI::Internal::Type::BaseModel
+        # @!attribute id
+        #   The ID of the tool call.
+        #
+        #   @return [String]
+        required :id, String
+
+        # @!attribute custom
+        #   The custom tool that the model called.
+        #
+        #   @return [OpenAI::Models::Chat::ChatCompletionMessageCustomToolCall::Custom]
+        required :custom, -> { OpenAI::Chat::ChatCompletionMessageCustomToolCall::Custom }
+
+        # @!attribute type
+        #   The type of the tool. Always `custom`.
+        #
+        #   @return [Symbol, :custom]
+        required :type, const: :custom
+
+        # @!method initialize(id:, custom:, type: :custom)
+        #   A call to a custom tool created by the model.
+        #
+        #   @param id [String] The ID of the tool call.
+        #
+        #   @param custom [OpenAI::Models::Chat::ChatCompletionMessageCustomToolCall::Custom] The custom tool that the model called.
+        #
+        #   @param type [Symbol, :custom] The type of the tool. Always `custom`.
+
+        # @see OpenAI::Models::Chat::ChatCompletionMessageCustomToolCall#custom
+        class Custom < OpenAI::Internal::Type::BaseModel
+          # @!attribute input
+          #   The input for the custom tool call generated by the model.
+          #
+          #   @return [String]
+          required :input, String
+
+          # @!attribute name
+          #   The name of the custom tool to call.
+          #
+          #   @return [String]
+          required :name, String
+
+          # @!method initialize(input:, name:)
+          #   The custom tool that the model called.
+          #
+          #   @param input [String] The input for the custom tool call generated by the model.
+          #
+          #   @param name [String] The name of the custom tool to call.
+        end
+      end
+    end
+
+    ChatCompletionMessageCustomToolCall = Chat::ChatCompletionMessageCustomToolCall
+  end
+end

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

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Chat
+      class ChatCompletionMessageFunctionToolCall < OpenAI::Internal::Type::BaseModel
+        # @!attribute id
+        #   The ID of the tool call.
+        #
+        #   @return [String]
+        required :id, String
+
+        # @!attribute function
+        #   The function that the model called.
+        #
+        #   @return [OpenAI::Models::Chat::ChatCompletionMessageFunctionToolCall::Function]
+        required :function, -> { OpenAI::Chat::ChatCompletionMessageFunctionToolCall::Function }
+
+        # @!attribute type
+        #   The type of the tool. Currently, only `function` is supported.
+        #
+        #   @return [Symbol, :function]
+        required :type, const: :function
+
+        # @!method initialize(id:, function:, type: :function)
+        #   A call to a function tool created by the model.
+        #
+        #   @param id [String] The ID of the tool call.
+        #
+        #   @param function [OpenAI::Models::Chat::ChatCompletionMessageFunctionToolCall::Function] The function that the model called.
+        #
+        #   @param type [Symbol, :function] The type of the tool. Currently, only `function` is supported.
+
+        # @see OpenAI::Models::Chat::ChatCompletionMessageFunctionToolCall#function
+        class Function < OpenAI::Internal::Type::BaseModel
+          # @!attribute arguments
+          #   The arguments to call the function with, as generated by the model in JSON
+          #   format. Note that the model does not always generate valid JSON, and may
+          #   hallucinate parameters not defined by your function schema. Validate the
+          #   arguments in your code before calling your function.
+          #
+          #   @return [String]
+          required :arguments, String
+
+          # @!attribute parsed
+          #   The parsed contents of the arguments.
+          #
+          #   @return [Object, nil]
+          required :parsed, OpenAI::StructuredOutput::ParsedJson
+
+          # @!attribute name
+          #   The name of the function to call.
+          #
+          #   @return [String]
+          required :name, String
+
+          # @!method initialize(arguments:, name:)
+          #   Some parameter documentations has been truncated, see
+          #   {OpenAI::Models::Chat::ChatCompletionMessageFunctionToolCall::Function} for more
+          #   details.
+          #
+          #   The function that the model called.
+          #
+          #   @param arguments [String] The arguments to call the function with, as generated by the model in JSON forma
+          #
+          #   @param name [String] The name of the function to call.
+        end
+      end
+    end
+
+    ChatCompletionMessageFunctionToolCall = Chat::ChatCompletionMessageFunctionToolCall
+  end
+end

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

@@ -3,66 +3,20 @@
 module OpenAI
   module Models
     module Chat
-      class ChatCompletionMessageToolCall < OpenAI::Internal::Type::BaseModel
-        # @!attribute id
-        #   The ID of the tool call.
-        #
-        #   @return [String]
-        required :id, String
+      # A call to a function tool created by the model.
+      module ChatCompletionMessageToolCall
+        extend OpenAI::Internal::Type::Union
 
-        # @!attribute function
-        #   The function that the model called.
-        #
-        #   @return [OpenAI::Models::Chat::ChatCompletionMessageToolCall::Function]
-        required :function, -> { OpenAI::Chat::ChatCompletionMessageToolCall::Function }
+        discriminator :type
 
-        # @!attribute type
-        #   The type of the tool. Currently, only `function` is supported.
-        #
-        #   @return [Symbol, :function]
-        required :type, const: :function
+        # A call to a function tool created by the model.
+        variant :function, -> { OpenAI::Chat::ChatCompletionMessageFunctionToolCall }
 
-        # @!method initialize(id:, function:, type: :function)
-        #   @param id [String] The ID of the tool call.
-        #
-        #   @param function [OpenAI::Models::Chat::ChatCompletionMessageToolCall::Function] The function that the model called.
-        #
-        #   @param type [Symbol, :function] The type of the tool. Currently, only `function` is supported.
+        # A call to a custom tool created by the model.
+        variant :custom, -> { OpenAI::Chat::ChatCompletionMessageCustomToolCall }
 
-        # @see OpenAI::Models::Chat::ChatCompletionMessageToolCall#function
-        class Function < OpenAI::Internal::Type::BaseModel
-          # @!attribute arguments
-          #   The arguments to call the function with, as generated by the model in JSON
-          #   format. Note that the model does not always generate valid JSON, and may
-          #   hallucinate parameters not defined by your function schema. Validate the
-          #   arguments in your code before calling your function.
-          #
-          #   @return [String]
-          required :arguments, String
-
-          # @!attribute parsed
-          #   The parsed contents of the arguments.
-          #
-          #   @return [Object, nil]
-          required :parsed, OpenAI::StructuredOutput::ParsedJson
-
-          # @!attribute name
-          #   The name of the function to call.
-          #
-          #   @return [String]
-          required :name, String
-
-          # @!method initialize(arguments:, name:)
-          #   Some parameter documentations has been truncated, see
-          #   {OpenAI::Models::Chat::ChatCompletionMessageToolCall::Function} for more
-          #   details.
-          #
-          #   The function that the model called.
-          #
-          #   @param arguments [String] The arguments to call the function with, as generated by the model in JSON forma
-          #
-          #   @param name [String] The name of the function to call.
-        end
+        # @!method self.variants
+        #   @return [Array(OpenAI::Models::Chat::ChatCompletionMessageFunctionToolCall, OpenAI::Models::Chat::ChatCompletionMessageCustomToolCall)]
       end
     end
 

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

@@ -10,7 +10,7 @@ module OpenAI
         required :function, -> { OpenAI::Chat::ChatCompletionNamedToolChoice::Function }
 
         # @!attribute type
-        #   The type of the tool. Currently, only `function` is supported.
+        #   For function calling, the type is always `function`.
         #
         #   @return [Symbol, :function]
         required :type, const: :function
@@ -21,7 +21,7 @@ module OpenAI
         #
         #   @param function [OpenAI::Models::Chat::ChatCompletionNamedToolChoice::Function]
         #
-        #   @param type [Symbol, :function] The type of the tool. Currently, only `function` is supported.
+        #   @param type [Symbol, :function] For function calling, the type is always `function`.
 
         # @see OpenAI::Models::Chat::ChatCompletionNamedToolChoice#function
         class Function < OpenAI::Internal::Type::BaseModel

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Chat
+      class ChatCompletionNamedToolChoiceCustom < OpenAI::Internal::Type::BaseModel
+        # @!attribute custom
+        #
+        #   @return [OpenAI::Models::Chat::ChatCompletionNamedToolChoiceCustom::Custom]
+        required :custom, -> { OpenAI::Chat::ChatCompletionNamedToolChoiceCustom::Custom }
+
+        # @!attribute type
+        #   For custom tool calling, the type is always `custom`.
+        #
+        #   @return [Symbol, :custom]
+        required :type, const: :custom
+
+        # @!method initialize(custom:, type: :custom)
+        #   Specifies a tool the model should use. Use to force the model to call a specific
+        #   custom tool.
+        #
+        #   @param custom [OpenAI::Models::Chat::ChatCompletionNamedToolChoiceCustom::Custom]
+        #
+        #   @param type [Symbol, :custom] For custom tool calling, the type is always `custom`.
+
+        # @see OpenAI::Models::Chat::ChatCompletionNamedToolChoiceCustom#custom
+        class Custom < OpenAI::Internal::Type::BaseModel
+          # @!attribute name
+          #   The name of the custom tool to call.
+          #
+          #   @return [String]
+          required :name, String
+
+          # @!method initialize(name:)
+          #   @param name [String] The name of the custom tool to call.
+        end
+      end
+    end
+
+    ChatCompletionNamedToolChoiceCustom = Chat::ChatCompletionNamedToolChoiceCustom
+  end
+end

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

@@ -10,10 +10,41 @@ module OpenAI
         #   @return [String]
         required :id, String
 
-        # @!method initialize(id:)
+        # @!attribute content_parts
+        #   If a content parts array was provided, this is an array of `text` and
+        #   `image_url` parts. Otherwise, null.
+        #
+        #   @return [Array<OpenAI::Models::Chat::ChatCompletionContentPartText, OpenAI::Models::Chat::ChatCompletionContentPartImage>, nil]
+        optional :content_parts,
+                 -> {
+                   OpenAI::Internal::Type::ArrayOf[union: OpenAI::Chat::ChatCompletionStoreMessage::ContentPart]
+                 },
+                 nil?: true
+
+        # @!method initialize(id:, content_parts: nil)
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Chat::ChatCompletionStoreMessage} for more details.
+        #
         #   A chat completion message generated by the model.
         #
         #   @param id [String] The identifier of the chat message.
+        #
+        #   @param content_parts [Array<OpenAI::Models::Chat::ChatCompletionContentPartText, OpenAI::Models::Chat::ChatCompletionContentPartImage>, nil] If a content parts array was provided, this is an array of `text` and `image_url
+
+        # Learn about
+        # [text inputs](https://platform.openai.com/docs/guides/text-generation).
+        module ContentPart
+          extend OpenAI::Internal::Type::Union
+
+          # Learn about [text inputs](https://platform.openai.com/docs/guides/text-generation).
+          variant -> { OpenAI::Chat::ChatCompletionContentPartText }
+
+          # Learn about [image inputs](https://platform.openai.com/docs/guides/vision).
+          variant -> { OpenAI::Chat::ChatCompletionContentPartImage }
+
+          # @!method self.variants
+          #   @return [Array(OpenAI::Models::Chat::ChatCompletionContentPartText, OpenAI::Models::Chat::ChatCompletionContentPartImage)]
+        end
       end
     end
 

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

@@ -4,6 +4,17 @@ module OpenAI
   module Models
     module Chat
       class ChatCompletionStreamOptions < OpenAI::Internal::Type::BaseModel
+        # @!attribute include_obfuscation
+        #   When true, stream obfuscation will be enabled. Stream obfuscation adds random
+        #   characters to an `obfuscation` field on streaming delta events to normalize
+        #   payload sizes as a mitigation to certain side-channel attacks. These obfuscation
+        #   fields are included by default, but add a small amount of overhead to the data
+        #   stream. You can set `include_obfuscation` to false to optimize for bandwidth if
+        #   you trust the network links between your application and the OpenAI API.
+        #
+        #   @return [Boolean, nil]
+        optional :include_obfuscation, OpenAI::Internal::Type::Boolean
+
         # @!attribute include_usage
         #   If set, an additional chunk will be streamed before the `data: [DONE]` message.
         #   The `usage` field on this chunk shows the token usage statistics for the entire
@@ -16,12 +27,14 @@ module OpenAI
         #   @return [Boolean, nil]
         optional :include_usage, OpenAI::Internal::Type::Boolean
 
-        # @!method initialize(include_usage: nil)
+        # @!method initialize(include_obfuscation: nil, include_usage: nil)
         #   Some parameter documentations has been truncated, see
         #   {OpenAI::Models::Chat::ChatCompletionStreamOptions} for more details.
         #
         #   Options for streaming response. Only set this when you set `stream: true`.
         #
+        #   @param include_obfuscation [Boolean] When true, stream obfuscation will be enabled. Stream obfuscation adds
+        #
         #   @param include_usage [Boolean] If set, an additional chunk will be streamed before the `data: [DONE]`
       end
     end

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

@@ -3,22 +3,20 @@
 module OpenAI
   module Models
     module Chat
-      class ChatCompletionTool < OpenAI::Internal::Type::BaseModel
-        # @!attribute function
-        #
-        #   @return [OpenAI::Models::FunctionDefinition]
-        required :function, -> { OpenAI::FunctionDefinition }
+      # A function tool that can be used to generate a response.
+      module ChatCompletionTool
+        extend OpenAI::Internal::Type::Union
 
-        # @!attribute type
-        #   The type of the tool. Currently, only `function` is supported.
-        #
-        #   @return [Symbol, :function]
-        required :type, const: :function
+        discriminator :type
 
-        # @!method initialize(function:, type: :function)
-        #   @param function [OpenAI::Models::FunctionDefinition]
-        #
-        #   @param type [Symbol, :function] The type of the tool. Currently, only `function` is supported.
+        # A function tool that can be used to generate a response.
+        variant :function, -> { OpenAI::Chat::ChatCompletionFunctionTool }
+
+        # A custom tool that processes input using a specified format.
+        variant :custom, -> { OpenAI::Chat::ChatCompletionCustomTool }
+
+        # @!method self.variants
+        #   @return [Array(OpenAI::Models::Chat::ChatCompletionFunctionTool, OpenAI::Models::Chat::ChatCompletionCustomTool)]
       end
     end
 

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

@@ -18,9 +18,15 @@ module OpenAI
         # `none` means the model will not call any tool and instead generates a message. `auto` means the model can pick between generating a message or calling one or more tools. `required` means the model must call one or more tools.
         variant enum: -> { OpenAI::Chat::ChatCompletionToolChoiceOption::Auto }
 
+        # Constrains the tools available to the model to a pre-defined set.
+        variant -> { OpenAI::Chat::ChatCompletionAllowedToolChoice }
+
         # Specifies a tool the model should use. Use to force the model to call a specific function.
         variant -> { OpenAI::Chat::ChatCompletionNamedToolChoice }
 
+        # Specifies a tool the model should use. Use to force the model to call a specific custom tool.
+        variant -> { OpenAI::Chat::ChatCompletionNamedToolChoiceCustom }
+
         # `none` means the model will not call any tool and instead generates a message.
         # `auto` means the model can pick between generating a message or calling one or
         # more tools. `required` means the model must call one or more tools.
@@ -36,7 +42,7 @@ module OpenAI
         end
 
         # @!method self.variants
-        #   @return [Array(Symbol, OpenAI::Models::Chat::ChatCompletionToolChoiceOption::Auto, OpenAI::Models::Chat::ChatCompletionNamedToolChoice)]
+        #   @return [Array(Symbol, OpenAI::Models::Chat::ChatCompletionToolChoiceOption::Auto, OpenAI::Models::Chat::ChatCompletionAllowedToolChoice, OpenAI::Models::Chat::ChatCompletionNamedToolChoice, OpenAI::Models::Chat::ChatCompletionNamedToolChoiceCustom)]
       end
     end