openai 0.15.0 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e15e098317bf9151fffc0d83be9fd3ead36872a58ea53628f2d0dd3028735c78
-  data.tar.gz: 04a779ac9f0b4418138bf4a7216e01109e48d608d76c33fc83f76e9de82d574e
+  metadata.gz: 6413e169f6a035774a4322aa42bbce1b9374344c1f68c5d452be6b0dffcd9756
+  data.tar.gz: 1ef928f4030023fd8a2076b08c3077f8ee7b9d95eef046eebbfc72004d46d327
 SHA512:
-  metadata.gz: d3673d18e0d3cfcd0db2ddc4c9c45bc6da8dd86371a38d85f7ad181f45780e6a17b48b9478e621c47a17c1708a2ec775ae8b61c0f6eb39c6b9d6686e09edfb65
-  data.tar.gz: a7fc556be0b4ba6ea16e6a2ba37bb0e9f62c2f7e39344a372b02b4c54b752e5718e15bfea4ffd8c277dd8db4f6d19530dc29e1ee5aee3fb2fc9a253269944b8f
+  metadata.gz: cf5a3da338b678f1680b605d0cd5a383ca95d601706422e5bedd5131e7ee7d91f01941b7f913368cec2e007fc684309e64e449e52e724a3c7a764c993c3d9e53
+  data.tar.gz: ebb89edd3814ee447bcfababcb05662d26e7380fb024c943cb5fa30196fcc6c49aea64c820de4fe8256f2acdf20562544e41a410084d1e34c774cf179329dc47

data/CHANGELOG.md

@@ -1,5 +1,52 @@
 # 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)
+
+### Features
+
+* add output_text method for non-streaming responses ([#757](https://github.com/openai/openai-ruby/issues/757)) ([50cf119](https://github.com/openai/openai-ruby/commit/50cf119106f9e16d9ac6a9898028b6d563a6f809))
+* **api:** manual updates ([e9fa8a0](https://github.com/openai/openai-ruby/commit/e9fa8a08d6ecebdd06212eaf6b9103082b7d67aa))
+
+
+### Bug Fixes
+
+* **internal:** ensure sorbet test always runs serially ([0601061](https://github.com/openai/openai-ruby/commit/0601061047525d16cc2afac64e5a4de0dd9de2e5))
+* provide parsed outputs for resumed streams ([#756](https://github.com/openai/openai-ruby/issues/756)) ([82254f9](https://github.com/openai/openai-ruby/commit/82254f980ccc0affa2555a81b0d8ed5aa0290835))
+* union definition re-using ([#760](https://github.com/openai/openai-ruby/issues/760)) ([3046c28](https://github.com/openai/openai-ruby/commit/3046c28935ca925c2f399f0350937d04eab54c0a))
+
+
+### Chores
+
+* extract reused JSON schema references even in unions ([#761](https://github.com/openai/openai-ruby/issues/761)) ([e17d3bf](https://github.com/openai/openai-ruby/commit/e17d3bf1fdf241f7a78ed72a39ddecabeb5877c8))
+* **internal:** refactor variable name ([#762](https://github.com/openai/openai-ruby/issues/762)) ([7e15b07](https://github.com/openai/openai-ruby/commit/7e15b0745dcbd3bf7fc4c1899d9d76e0a9ab1e48))
+* update contribute.md ([b4a0297](https://github.com/openai/openai-ruby/commit/b4a029775bb52d5db2f3fac235595f37b6746a61))
+
 ## 0.15.0 (2025-07-21)
 
 Full Changelog: [v0.14.0...v0.15.0](https://github.com/openai/openai-ruby/compare/v0.14.0...v0.15.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.15.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/helpers/structured_output/json_schema_converter.rb

@@ -6,15 +6,9 @@ module OpenAI
       # To customize the JSON schema conversion for a type, implement the `JsonSchemaConverter` interface.
       module JsonSchemaConverter
         # @api private
-        POINTER = Object.new.tap do
+        POINTERS = Object.new.tap do
           _1.define_singleton_method(:inspect) do
-            "#<#{OpenAI::Helpers::StructuredOutput::JsonSchemaConverter}::POINTER>"
-          end
-        end.freeze
-        # @api private
-        COUNTER = Object.new.tap do
-          _1.define_singleton_method(:inspect) do
-            "#<#{OpenAI::Helpers::StructuredOutput::JsonSchemaConverter}::COUNTER>"
+            "#<#{OpenAI::Helpers::StructuredOutput::JsonSchemaConverter}::POINTERS>"
           end
         end.freeze
         # @api private
@@ -81,14 +75,15 @@ module OpenAI
           def cache_def!(state, type:, &blk)
             defs, path = state.fetch_values(:defs, :path)
             if (stored = defs[type])
-              stored[OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::COUNTER] += 1
-              stored.fetch(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTER)
+              pointers = stored.fetch(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTERS)
+              pointers.first.except(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::NO_REF).tap do
+                pointers << _1
+              end
             else
               ref_path = String.new
               ref = {"$ref": ref_path}
               stored = {
-                OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTER => ref,
-                OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::COUNTER => 1
+                OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTERS => [ref]
               }
               defs.store(type, stored)
               schema = blk.call
@@ -112,17 +107,21 @@ module OpenAI
             )
             reused_defs = {}
             defs.each_value do |acc|
-              ref = acc.fetch(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTER)
-              if (no_ref = ref.delete(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::NO_REF))
-                acc[OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::COUNTER] -= 1
+              sch = acc.except(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTERS)
+              pointers = acc.fetch(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTERS)
+
+              no_refs, refs = pointers.partition do
+                _1.delete(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::NO_REF)
               end
-              cnt = acc.fetch(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::COUNTER)
 
-              sch = acc.except(
-                OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::POINTER,
-                OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::COUNTER
-              )
-              cnt > 1 && !no_ref ? reused_defs.store(ref.fetch(:$ref), sch) : ref.replace(sch)
+              case refs
+              in [ref]
+                ref.replace(sch)
+              in [_, ref, *]
+                reused_defs.store(ref.fetch(:$ref), sch)
+              else
+              end
+              no_refs.each { _1.replace(sch) }
             end
 
             xformed = reused_defs.transform_keys { _1.delete_prefix("#/$defs/") }

data/lib/openai/helpers/structured_output/union_of.rb

@@ -36,7 +36,17 @@ module OpenAI
               mergeable_keys.each_key { mergeable_keys[_1] += 1 if schema.keys == _1 }
             end
             mergeable = mergeable_keys.any? { _1.last == schemas.length }
-            mergeable ? OpenAI::Internal::Util.deep_merge(*schemas, concat: true) : {anyOf: schemas}
+            if mergeable
+              OpenAI::Internal::Util.deep_merge(*schemas, concat: true)
+            else
+              {
+                anyOf: schemas.each do
+                  if _1.key?(:$ref)
+                    _1.update(OpenAI::Helpers::StructuredOutput::JsonSchemaConverter::NO_REF => true)
+                  end
+                end
+              }
+            end
           end
         end
 

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`.