openai 0.16.0 → 0.17.0

data/rbi/openai/models/responses/response_output_item_added_event.rbi

@@ -44,7 +44,8 @@ module OpenAI
                 OpenAI::Responses::ResponseOutputItem::LocalShellCall::OrHash,
                 OpenAI::Responses::ResponseOutputItem::McpCall::OrHash,
                 OpenAI::Responses::ResponseOutputItem::McpListTools::OrHash,
-                OpenAI::Responses::ResponseOutputItem::McpApprovalRequest::OrHash
+                OpenAI::Responses::ResponseOutputItem::McpApprovalRequest::OrHash,
+                OpenAI::Responses::ResponseCustomToolCall::OrHash
               ),
             output_index: Integer,
             sequence_number: Integer,

data/rbi/openai/models/responses/response_output_item_done_event.rbi

@@ -44,7 +44,8 @@ module OpenAI
                 OpenAI::Responses::ResponseOutputItem::LocalShellCall::OrHash,
                 OpenAI::Responses::ResponseOutputItem::McpCall::OrHash,
                 OpenAI::Responses::ResponseOutputItem::McpListTools::OrHash,
-                OpenAI::Responses::ResponseOutputItem::McpApprovalRequest::OrHash
+                OpenAI::Responses::ResponseOutputItem::McpApprovalRequest::OrHash,
+                OpenAI::Responses::ResponseCustomToolCall::OrHash
               ),
             output_index: Integer,
             sequence_number: Integer,

data/rbi/openai/models/responses/response_reasoning_item.rbi

@@ -16,7 +16,7 @@ module OpenAI
         sig { returns(String) }
         attr_accessor :id
 
-        # Reasoning text contents.
+        # Reasoning summary content.
         sig do
           returns(T::Array[OpenAI::Responses::ResponseReasoningItem::Summary])
         end
@@ -26,6 +26,26 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # Reasoning text content.
+        sig do
+          returns(
+            T.nilable(
+              T::Array[OpenAI::Responses::ResponseReasoningItem::Content]
+            )
+          )
+        end
+        attr_reader :content
+
+        sig do
+          params(
+            content:
+              T::Array[
+                OpenAI::Responses::ResponseReasoningItem::Content::OrHash
+              ]
+          ).void
+        end
+        attr_writer :content
+
         # The encrypted content of the reasoning item - populated when a response is
         # generated with `reasoning.encrypted_content` in the `include` parameter.
         sig { returns(T.nilable(String)) }
@@ -60,6 +80,10 @@ module OpenAI
               T::Array[
                 OpenAI::Responses::ResponseReasoningItem::Summary::OrHash
               ],
+            content:
+              T::Array[
+                OpenAI::Responses::ResponseReasoningItem::Content::OrHash
+              ],
             encrypted_content: T.nilable(String),
             status: OpenAI::Responses::ResponseReasoningItem::Status::OrSymbol,
             type: Symbol
@@ -68,8 +92,10 @@ module OpenAI
         def self.new(
           # The unique identifier of the reasoning content.
           id:,
-          # Reasoning text contents.
+          # Reasoning summary content.
           summary:,
+          # Reasoning text content.
+          content: nil,
           # The encrypted content of the reasoning item - populated when a response is
           # generated with `reasoning.encrypted_content` in the `include` parameter.
           encrypted_content: nil,
@@ -88,6 +114,8 @@ module OpenAI
               summary:
                 T::Array[OpenAI::Responses::ResponseReasoningItem::Summary],
               type: Symbol,
+              content:
+                T::Array[OpenAI::Responses::ResponseReasoningItem::Content],
               encrypted_content: T.nilable(String),
               status: OpenAI::Responses::ResponseReasoningItem::Status::OrSymbol
             }
@@ -105,7 +133,7 @@ module OpenAI
               )
             end
 
-          # A short summary of the reasoning used by the model when generating the response.
+          # A summary of the reasoning output from the model so far.
           sig { returns(String) }
           attr_accessor :text
 
@@ -115,7 +143,7 @@ module OpenAI
 
           sig { params(text: String, type: Symbol).returns(T.attached_class) }
           def self.new(
-            # A short summary of the reasoning used by the model when generating the response.
+            # A summary of the reasoning output from the model so far.
             text:,
             # The type of the object. Always `summary_text`.
             type: :summary_text
@@ -127,6 +155,37 @@ module OpenAI
           end
         end
 
+        class Content < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ResponseReasoningItem::Content,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # Reasoning text output from the model.
+          sig { returns(String) }
+          attr_accessor :text
+
+          # The type of the object. Always `reasoning_text`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { params(text: String, type: Symbol).returns(T.attached_class) }
+          def self.new(
+            # Reasoning text output from the model.
+            text:,
+            # The type of the object. Always `reasoning_text`.
+            type: :reasoning_text
+          )
+          end
+
+          sig { override.returns({ text: String, type: Symbol }) }
+          def to_hash
+          end
+        end
+
         # The status of the item. One of `in_progress`, `completed`, or `incomplete`.
         # Populated when items are returned via API.
         module Status

data/rbi/openai/models/responses/response_reasoning_text_delta_event.rbi

@@ -0,0 +1,83 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      class ResponseReasoningTextDeltaEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseReasoningTextDeltaEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The index of the reasoning content part this delta is associated with.
+        sig { returns(Integer) }
+        attr_accessor :content_index
+
+        # The text delta that was added to the reasoning content.
+        sig { returns(String) }
+        attr_accessor :delta
+
+        # The ID of the item this reasoning text delta is associated with.
+        sig { returns(String) }
+        attr_accessor :item_id
+
+        # The index of the output item this reasoning text delta is associated with.
+        sig { returns(Integer) }
+        attr_accessor :output_index
+
+        # The sequence number of this event.
+        sig { returns(Integer) }
+        attr_accessor :sequence_number
+
+        # The type of the event. Always `response.reasoning_text.delta`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Emitted when a delta is added to a reasoning text.
+        sig do
+          params(
+            content_index: Integer,
+            delta: String,
+            item_id: String,
+            output_index: Integer,
+            sequence_number: Integer,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The index of the reasoning content part this delta is associated with.
+          content_index:,
+          # The text delta that was added to the reasoning content.
+          delta:,
+          # The ID of the item this reasoning text delta is associated with.
+          item_id:,
+          # The index of the output item this reasoning text delta is associated with.
+          output_index:,
+          # The sequence number of this event.
+          sequence_number:,
+          # The type of the event. Always `response.reasoning_text.delta`.
+          type: :"response.reasoning_text.delta"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              content_index: Integer,
+              delta: String,
+              item_id: String,
+              output_index: Integer,
+              sequence_number: Integer,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/{response_reasoning_summary_done_event.rbi → response_reasoning_text_done_event.rbi}

@@ -3,20 +3,24 @@
 module OpenAI
   module Models
     module Responses
-      class ResponseReasoningSummaryDoneEvent < OpenAI::Internal::Type::BaseModel
+      class ResponseReasoningTextDoneEvent < OpenAI::Internal::Type::BaseModel
         OrHash =
           T.type_alias do
             T.any(
-              OpenAI::Responses::ResponseReasoningSummaryDoneEvent,
+              OpenAI::Responses::ResponseReasoningTextDoneEvent,
               OpenAI::Internal::AnyHash
             )
           end
 
-        # The unique identifier of the item for which the reasoning summary is finalized.
+        # The index of the reasoning content part.
+        sig { returns(Integer) }
+        attr_accessor :content_index
+
+        # The ID of the item this reasoning text is associated with.
         sig { returns(String) }
         attr_accessor :item_id
 
-        # The index of the output item in the response's output array.
+        # The index of the output item this reasoning text is associated with.
         sig { returns(Integer) }
         attr_accessor :output_index
 
@@ -24,52 +28,48 @@ module OpenAI
         sig { returns(Integer) }
         attr_accessor :sequence_number
 
-        # The index of the summary part within the output item.
-        sig { returns(Integer) }
-        attr_accessor :summary_index
-
-        # The finalized reasoning summary text.
+        # The full text of the completed reasoning content.
         sig { returns(String) }
         attr_accessor :text
 
-        # The type of the event. Always 'response.reasoning_summary.done'.
+        # The type of the event. Always `response.reasoning_text.done`.
         sig { returns(Symbol) }
         attr_accessor :type
 
-        # Emitted when the reasoning summary content is finalized for an item.
+        # Emitted when a reasoning text is completed.
         sig do
           params(
+            content_index: Integer,
             item_id: String,
             output_index: Integer,
             sequence_number: Integer,
-            summary_index: Integer,
             text: String,
             type: Symbol
           ).returns(T.attached_class)
         end
         def self.new(
-          # The unique identifier of the item for which the reasoning summary is finalized.
+          # The index of the reasoning content part.
+          content_index:,
+          # The ID of the item this reasoning text is associated with.
           item_id:,
-          # The index of the output item in the response's output array.
+          # The index of the output item this reasoning text is associated with.
           output_index:,
           # The sequence number of this event.
           sequence_number:,
-          # The index of the summary part within the output item.
-          summary_index:,
-          # The finalized reasoning summary text.
+          # The full text of the completed reasoning content.
           text:,
-          # The type of the event. Always 'response.reasoning_summary.done'.
-          type: :"response.reasoning_summary.done"
+          # The type of the event. Always `response.reasoning_text.done`.
+          type: :"response.reasoning_text.done"
         )
         end
 
         sig do
           override.returns(
             {
+              content_index: Integer,
               item_id: String,
               output_index: Integer,
               sequence_number: Integer,
-              summary_index: Integer,
               text: String,
               type: Symbol
             }

data/rbi/openai/models/responses/response_retrieve_params.rbi

@@ -31,6 +31,18 @@ module OpenAI
         end
         attr_writer :include
 
+        # 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.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :include_obfuscation
+
+        sig { params(include_obfuscation: T::Boolean).void }
+        attr_writer :include_obfuscation
+
         # The sequence number of the event after which to start streaming.
         sig { returns(T.nilable(Integer)) }
         attr_reader :starting_after
@@ -41,6 +53,7 @@ module OpenAI
         sig do
           params(
             include: T::Array[OpenAI::Responses::ResponseIncludable::OrSymbol],
+            include_obfuscation: T::Boolean,
             starting_after: Integer,
             request_options: OpenAI::RequestOptions::OrHash
           ).returns(T.attached_class)
@@ -49,6 +62,13 @@ module OpenAI
           # Additional fields to include in the response. See the `include` parameter for
           # Response creation above for more information.
           include: nil,
+          # 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.
+          include_obfuscation: nil,
           # The sequence number of the event after which to start streaming.
           starting_after: nil,
           request_options: {}
@@ -60,6 +80,7 @@ module OpenAI
             {
               include:
                 T::Array[OpenAI::Responses::ResponseIncludable::OrSymbol],
+              include_obfuscation: T::Boolean,
               starting_after: Integer,
               request_options: OpenAI::RequestOptions
             }

data/rbi/openai/models/responses/response_stream_event.rbi

@@ -38,6 +38,8 @@ module OpenAI
               OpenAI::Responses::ResponseReasoningSummaryPartDoneEvent,
               OpenAI::Responses::ResponseReasoningSummaryTextDeltaEvent,
               OpenAI::Responses::ResponseReasoningSummaryTextDoneEvent,
+              OpenAI::Responses::ResponseReasoningTextDeltaEvent,
+              OpenAI::Responses::ResponseReasoningTextDoneEvent,
               OpenAI::Responses::ResponseRefusalDeltaEvent,
               OpenAI::Responses::ResponseRefusalDoneEvent,
               OpenAI::Responses::ResponseTextDeltaEvent,
@@ -59,8 +61,8 @@ module OpenAI
               OpenAI::Responses::ResponseMcpListToolsInProgressEvent,
               OpenAI::Responses::ResponseOutputTextAnnotationAddedEvent,
               OpenAI::Responses::ResponseQueuedEvent,
-              OpenAI::Responses::ResponseReasoningSummaryDeltaEvent,
-              OpenAI::Responses::ResponseReasoningSummaryDoneEvent
+              OpenAI::Responses::ResponseCustomToolCallInputDeltaEvent,
+              OpenAI::Responses::ResponseCustomToolCallInputDoneEvent
             )
           end
 

data/rbi/openai/models/responses/response_text_config.rbi

@@ -50,6 +50,18 @@ module OpenAI
         end
         attr_writer :format_
 
+        # Constrains the verbosity of the model's response. Lower values will result in
+        # more concise responses, while higher values will result in more verbose
+        # responses. Currently supported values are `low`, `medium`, and `high`.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Responses::ResponseTextConfig::Verbosity::OrSymbol
+            )
+          )
+        end
+        attr_accessor :verbosity
+
         # Configuration options for a text response from the model. Can be plain text or
         # structured JSON data. Learn more:
         #
@@ -62,6 +74,10 @@ module OpenAI
                 OpenAI::ResponseFormatText::OrHash,
                 OpenAI::Responses::ResponseFormatTextJSONSchemaConfig::OrHash,
                 OpenAI::ResponseFormatJSONObject::OrHash
+              ),
+            verbosity:
+              T.nilable(
+                OpenAI::Responses::ResponseTextConfig::Verbosity::OrSymbol
               )
           ).returns(T.attached_class)
         end
@@ -79,7 +95,11 @@ module OpenAI
           # 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
+          format_: nil,
+          # Constrains the verbosity of the model's response. Lower values will result in
+          # more concise responses, while higher values will result in more verbose
+          # responses. Currently supported values are `low`, `medium`, and `high`.
+          verbosity: nil
         )
         end
 
@@ -91,12 +111,55 @@ module OpenAI
                   OpenAI::ResponseFormatText,
                   OpenAI::Responses::ResponseFormatTextJSONSchemaConfig,
                   OpenAI::ResponseFormatJSONObject
+                ),
+              verbosity:
+                T.nilable(
+                  OpenAI::Responses::ResponseTextConfig::Verbosity::OrSymbol
                 )
             }
           )
         end
         def to_hash
         end
+
+        # Constrains the verbosity of the model's response. Lower values will result in
+        # more concise responses, while higher values will result in more verbose
+        # responses. Currently supported values are `low`, `medium`, and `high`.
+        module Verbosity
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, OpenAI::Responses::ResponseTextConfig::Verbosity)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          LOW =
+            T.let(
+              :low,
+              OpenAI::Responses::ResponseTextConfig::Verbosity::TaggedSymbol
+            )
+          MEDIUM =
+            T.let(
+              :medium,
+              OpenAI::Responses::ResponseTextConfig::Verbosity::TaggedSymbol
+            )
+          HIGH =
+            T.let(
+              :high,
+              OpenAI::Responses::ResponseTextConfig::Verbosity::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Responses::ResponseTextConfig::Verbosity::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
       end
     end
   end

data/rbi/openai/models/responses/tool.rbi

@@ -17,6 +17,7 @@ module OpenAI
               OpenAI::Responses::Tool::CodeInterpreter,
               OpenAI::Responses::Tool::ImageGeneration,
               OpenAI::Responses::Tool::LocalShell,
+              OpenAI::Responses::CustomTool,
               OpenAI::Responses::WebSearchTool
             )
           end

data/rbi/openai/models/responses/tool_choice_allowed.rbi

@@ -0,0 +1,124 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      class ToolChoiceAllowed < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Responses::ToolChoiceAllowed,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # 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.
+        sig { returns(OpenAI::Responses::ToolChoiceAllowed::Mode::OrSymbol) }
+        attr_accessor :mode
+
+        # A list of tool definitions that the model should be allowed to call.
+        #
+        # For the Responses API, the list of tool definitions might look like:
+        #
+        # ```json
+        # [
+        #   { "type": "function", "name": "get_weather" },
+        #   { "type": "mcp", "server_label": "deepwiki" },
+        #   { "type": "image_generation" }
+        # ]
+        # ```
+        sig { returns(T::Array[T::Hash[Symbol, T.anything]]) }
+        attr_accessor :tools
+
+        # Allowed tool configuration type. Always `allowed_tools`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Constrains the tools available to the model to a pre-defined set.
+        sig do
+          params(
+            mode: OpenAI::Responses::ToolChoiceAllowed::Mode::OrSymbol,
+            tools: T::Array[T::Hash[Symbol, T.anything]],
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # 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.
+          mode:,
+          # A list of tool definitions that the model should be allowed to call.
+          #
+          # For the Responses API, the list of tool definitions might look like:
+          #
+          # ```json
+          # [
+          #   { "type": "function", "name": "get_weather" },
+          #   { "type": "mcp", "server_label": "deepwiki" },
+          #   { "type": "image_generation" }
+          # ]
+          # ```
+          tools:,
+          # Allowed tool configuration type. Always `allowed_tools`.
+          type: :allowed_tools
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              mode: OpenAI::Responses::ToolChoiceAllowed::Mode::OrSymbol,
+              tools: T::Array[T::Hash[Symbol, T.anything]],
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # 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.
+        module Mode
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, OpenAI::Responses::ToolChoiceAllowed::Mode)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          AUTO =
+            T.let(
+              :auto,
+              OpenAI::Responses::ToolChoiceAllowed::Mode::TaggedSymbol
+            )
+          REQUIRED =
+            T.let(
+              :required,
+              OpenAI::Responses::ToolChoiceAllowed::Mode::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[OpenAI::Responses::ToolChoiceAllowed::Mode::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/tool_choice_custom.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      class ToolChoiceCustom < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Responses::ToolChoiceCustom,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The name of the custom tool to call.
+        sig { returns(String) }
+        attr_accessor :name
+
+        # For custom tool calling, the type is always `custom`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Use this option to force the model to call a specific custom tool.
+        sig { params(name: String, type: Symbol).returns(T.attached_class) }
+        def self.new(
+          # The name of the custom tool to call.
+          name:,
+          # For custom tool calling, the type is always `custom`.
+          type: :custom
+        )
+        end
+
+        sig { override.returns({ name: String, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end