openai 0.79.0 → 0.81.0

data/rbi/openai/models/responses/responses_client_event.rbi

@@ -2,15 +2,17 @@
 
 module OpenAI
   module Models
+
     module Responses
+
       class ResponsesClientEvent < OpenAI::Internal::Type::BaseModel
-        OrHash =
-          T.type_alias do
-            T.any(
-              OpenAI::Responses::ResponsesClientEvent,
-              OpenAI::Internal::AnyHash
-            )
-          end
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Responses::ResponsesClientEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
 
         # The type of the client event. Always `response.create`.
         sig { returns(Symbol) }
@@ -22,28 +24,14 @@ module OpenAI
         attr_accessor :background
 
         # Context management configuration for this request.
-        sig do
-          returns(
-            T.nilable(
-              T::Array[
-                OpenAI::Responses::ResponsesClientEvent::ContextManagement
-              ]
-            )
-          )
-        end
+        sig { returns(T.nilable(T::Array[OpenAI::Responses::ResponsesClientEvent::ContextManagement])) }
         attr_accessor :context_management
 
         # The conversation that this response belongs to. Items from this conversation are
         # prepended to `input_items` for this response request. Input items and output
         # items from this response are automatically added to this conversation after this
         # response completes.
-        sig do
-          returns(
-            T.nilable(
-              T.any(String, OpenAI::Responses::ResponseConversationParam)
-            )
-          )
-        end
+        sig { returns(T.nilable(T.any(String, OpenAI::Responses::ResponseConversationParam))) }
         attr_accessor :conversation
 
         # Specify additional output data to include in the model response. Currently
@@ -64,11 +52,7 @@ module OpenAI
         #   multi-turn conversations when using the Responses API statelessly (like when
         #   the `store` parameter is set to `false`, or when an organization is enrolled
         #   in the zero data retention program).
-        sig do
-          returns(
-            T.nilable(T::Array[OpenAI::Responses::ResponseIncludable::OrSymbol])
-          )
-        end
+        sig { returns(T.nilable(T::Array[OpenAI::Responses::ResponseIncludable::OrSymbol])) }
         attr_accessor :include
 
         # Text, image, or file inputs to the model, used to generate a response.
@@ -80,18 +64,10 @@ module OpenAI
         # - [File inputs](https://platform.openai.com/docs/guides/pdf-files)
         # - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
         # - [Function calling](https://platform.openai.com/docs/guides/function-calling)
-        sig do
-          returns(
-            T.nilable(OpenAI::Responses::ResponsesClientEvent::Input::Variants)
-          )
-        end
+        sig { returns(T.nilable(OpenAI::Responses::ResponsesClientEvent::Input::Variants)) }
         attr_reader :input
 
-        sig do
-          params(
-            input: OpenAI::Responses::ResponsesClientEvent::Input::Variants
-          ).void
-        end
+        sig { params(input: OpenAI::Responses::ResponsesClientEvent::Input::Variants).void }
         attr_writer :input
 
         # A system (or developer) message inserted into the model's context.
@@ -129,47 +105,26 @@ module OpenAI
         # and price points. Refer to the
         # [model guide](https://platform.openai.com/docs/models) to browse and compare
         # available models.
-        sig do
+        sig {
           returns(
-            T.nilable(
-              T.any(
-                String,
-                OpenAI::ChatModel::OrSymbol,
-                OpenAI::ResponsesModel::ResponsesOnlyModel::OrSymbol
-              )
-            )
+            T.nilable(T.any(String, OpenAI::ChatModel::OrSymbol, OpenAI::ResponsesModel::ResponsesOnlyModel::OrSymbol))
           )
-        end
+        }
         attr_reader :model
 
-        sig do
+        sig {
           params(
-            model:
-              T.any(
-                String,
-                OpenAI::ChatModel::OrSymbol,
-                OpenAI::ResponsesModel::ResponsesOnlyModel::OrSymbol
-              )
-          ).void
-        end
+            model: T.any(String, OpenAI::ChatModel::OrSymbol, OpenAI::ResponsesModel::ResponsesOnlyModel::OrSymbol)
+          )
+            .void
+        }
         attr_writer :model
 
         # Configuration for running moderation on the input and output of this response.
-        sig do
-          returns(
-            T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation)
-          )
-        end
+        sig { returns(T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation)) }
         attr_reader :moderation
 
-        sig do
-          params(
-            moderation:
-              T.nilable(
-                OpenAI::Responses::ResponsesClientEvent::Moderation::OrHash
-              )
-          ).void
-        end
+        sig { params(moderation: T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::OrHash)).void }
         attr_writer :moderation
 
         # Whether to allow the model to run tool calls in parallel.
@@ -188,11 +143,7 @@ module OpenAI
         sig { returns(T.nilable(OpenAI::Responses::ResponsePrompt)) }
         attr_reader :prompt
 
-        sig do
-          params(
-            prompt: T.nilable(OpenAI::Responses::ResponsePrompt::OrHash)
-          ).void
-        end
+        sig { params(prompt: T.nilable(OpenAI::Responses::ResponsePrompt::OrHash)).void }
         attr_writer :prompt
 
         # Used by OpenAI to cache responses for similar requests to optimize your cache
@@ -210,21 +161,10 @@ module OpenAI
         # `ttl` defaults to `30m`, which is currently the only supported value. See the
         # [prompt caching guide](https://platform.openai.com/docs/guides/prompt-caching)
         # for current details.
-        sig do
-          returns(
-            T.nilable(
-              OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions
-            )
-          )
-        end
+        sig { returns(T.nilable(OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions)) }
         attr_reader :prompt_cache_options
 
-        sig do
-          params(
-            prompt_cache_options:
-              OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::OrHash
-          ).void
-        end
+        sig { params(prompt_cache_options: OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::OrHash).void }
         attr_writer :prompt_cache_options
 
         # Deprecated. Use `prompt_cache_options.ttl` instead.
@@ -244,13 +184,7 @@ module OpenAI
         # - Organizations without ZDR enabled default to `24h`.
         # - Organizations with ZDR enabled default to `in_memory` when
         #   `prompt_cache_retention` is not specified.
-        sig do
-          returns(
-            T.nilable(
-              OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention::OrSymbol
-            )
-          )
-        end
+        sig { returns(T.nilable(OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention::OrSymbol)) }
         attr_accessor :prompt_cache_retention
 
         # **gpt-5 and o-series models only**
@@ -286,19 +220,17 @@ module OpenAI
         #   Responses or Chat Completions. The response will show `service_tier=priority`
         #   regardless of if you specify `service_tier=fast` or `priority` in your
         #   request.
+        # - If set to 'ultrafast', then the request will be processed with the
+        #   access-controlled Ultrafast Processing service tier. This tier is currently
+        #   available for `gpt-5.6-sol`; a response served through it will show
+        #   `service_tier=ultrafast`.
         # - When not set, the default behavior is 'auto'.
         #
         # When the `service_tier` parameter is set, the response body will include the
         # `service_tier` value based on the processing mode actually used to serve the
         # request. This response value may be different from the value set in the
         # parameter.
-        sig do
-          returns(
-            T.nilable(
-              OpenAI::Responses::ResponsesClientEvent::ServiceTier::OrSymbol
-            )
-          )
-        end
+        sig { returns(T.nilable(OpenAI::Responses::ResponsesClientEvent::ServiceTier::OrSymbol)) }
         attr_accessor :service_tier
 
         # Whether to store the generated model response for later retrieval via API.
@@ -326,21 +258,10 @@ module OpenAI
         attr_writer :stream_id
 
         # Options for streaming responses. Only set this when you set `stream: true`.
-        sig do
-          returns(
-            T.nilable(OpenAI::Responses::ResponsesClientEvent::StreamOptions)
-          )
-        end
+        sig { returns(T.nilable(OpenAI::Responses::ResponsesClientEvent::StreamOptions)) }
         attr_reader :stream_options
 
-        sig do
-          params(
-            stream_options:
-              T.nilable(
-                OpenAI::Responses::ResponsesClientEvent::StreamOptions::OrHash
-              )
-          ).void
-        end
+        sig { params(stream_options: T.nilable(OpenAI::Responses::ResponsesClientEvent::StreamOptions::OrHash)).void }
         attr_writer :stream_options
 
         # What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
@@ -364,7 +285,7 @@ module OpenAI
         # How the model should select which tool (or tools) to use when generating a
         # response. See the `tools` parameter to see how to specify which tools the model
         # can call.
-        sig do
+        sig {
           returns(
             T.nilable(
               T.any(
@@ -380,25 +301,25 @@ module OpenAI
               )
             )
           )
-        end
+        }
         attr_reader :tool_choice
 
-        sig do
+        sig {
           params(
-            tool_choice:
-              T.any(
-                OpenAI::Responses::ToolChoiceOptions::OrSymbol,
-                OpenAI::Responses::ToolChoiceAllowed::OrHash,
-                OpenAI::Responses::ToolChoiceTypes::OrHash,
-                OpenAI::Responses::ToolChoiceFunction::OrHash,
-                OpenAI::Responses::ToolChoiceMcp::OrHash,
-                OpenAI::Responses::ToolChoiceCustom::OrHash,
-                OpenAI::Responses::ResponsesClientEvent::ToolChoice::SpecificProgrammaticToolCallingParam::OrHash,
-                OpenAI::Responses::ToolChoiceApplyPatch::OrHash,
-                OpenAI::Responses::ToolChoiceShell::OrHash
-              )
-          ).void
-        end
+            tool_choice: T.any(
+              OpenAI::Responses::ToolChoiceOptions::OrSymbol,
+              OpenAI::Responses::ToolChoiceAllowed::OrHash,
+              OpenAI::Responses::ToolChoiceTypes::OrHash,
+              OpenAI::Responses::ToolChoiceFunction::OrHash,
+              OpenAI::Responses::ToolChoiceMcp::OrHash,
+              OpenAI::Responses::ToolChoiceCustom::OrHash,
+              OpenAI::Responses::ResponsesClientEvent::ToolChoice::SpecificProgrammaticToolCallingParam::OrHash,
+              OpenAI::Responses::ToolChoiceApplyPatch::OrHash,
+              OpenAI::Responses::ToolChoiceShell::OrHash
+            )
+          )
+            .void
+        }
         attr_writer :tool_choice
 
         # An array of tools the model may call while generating a response. You can
@@ -420,7 +341,7 @@ module OpenAI
         #   Learn more about
         #   [function calling](https://platform.openai.com/docs/guides/function-calling).
         #   You can also use custom tools to call your own code.
-        sig do
+        sig {
           returns(
             T.nilable(
               T::Array[
@@ -445,34 +366,34 @@ module OpenAI
               ]
             )
           )
-        end
+        }
         attr_reader :tools
 
-        sig do
+        sig {
           params(
-            tools:
-              T::Array[
-                T.any(
-                  OpenAI::Responses::FunctionTool::OrHash,
-                  OpenAI::Responses::FileSearchTool::OrHash,
-                  OpenAI::Responses::ComputerTool::OrHash,
-                  OpenAI::Responses::ComputerUsePreviewTool::OrHash,
-                  OpenAI::Responses::Tool::Mcp::OrHash,
-                  OpenAI::Responses::Tool::CodeInterpreter::OrHash,
-                  OpenAI::Responses::Tool::ProgrammaticToolCalling::OrHash,
-                  OpenAI::Responses::Tool::ImageGeneration::OrHash,
-                  OpenAI::Responses::Tool::LocalShell::OrHash,
-                  OpenAI::Responses::FunctionShellTool::OrHash,
-                  OpenAI::Responses::CustomTool::OrHash,
-                  OpenAI::Responses::NamespaceTool::OrHash,
-                  OpenAI::Responses::ToolSearchTool::OrHash,
-                  OpenAI::Responses::ApplyPatchTool::OrHash,
-                  OpenAI::Responses::WebSearchTool::OrHash,
-                  OpenAI::Responses::WebSearchPreviewTool::OrHash
-                )
-              ]
-          ).void
-        end
+            tools: T::Array[
+              T.any(
+                OpenAI::Responses::FunctionTool::OrHash,
+                OpenAI::Responses::FileSearchTool::OrHash,
+                OpenAI::Responses::ComputerTool::OrHash,
+                OpenAI::Responses::ComputerUsePreviewTool::OrHash,
+                OpenAI::Responses::Tool::Mcp::OrHash,
+                OpenAI::Responses::Tool::CodeInterpreter::OrHash,
+                OpenAI::Responses::Tool::ProgrammaticToolCalling::OrHash,
+                OpenAI::Responses::Tool::ImageGeneration::OrHash,
+                OpenAI::Responses::Tool::LocalShell::OrHash,
+                OpenAI::Responses::FunctionShellTool::OrHash,
+                OpenAI::Responses::CustomTool::OrHash,
+                OpenAI::Responses::NamespaceTool::OrHash,
+                OpenAI::Responses::ToolSearchTool::OrHash,
+                OpenAI::Responses::ApplyPatchTool::OrHash,
+                OpenAI::Responses::WebSearchTool::OrHash,
+                OpenAI::Responses::WebSearchPreviewTool::OrHash
+              )
+            ]
+          )
+            .void
+        }
         attr_writer :tools
 
         # An integer between 0 and 20 specifying the maximum number of most likely tokens
@@ -496,13 +417,7 @@ module OpenAI
         #   items from the beginning of the conversation.
         # - `disabled` (default): If the input size will exceed the context window size
         #   for a model, the request will fail with a 400 error.
-        sig do
-          returns(
-            T.nilable(
-              OpenAI::Responses::ResponsesClientEvent::Truncation::OrSymbol
-            )
-          )
-        end
+        sig { returns(T.nilable(OpenAI::Responses::ResponsesClientEvent::Truncation::OrSymbol)) }
         attr_accessor :truncation
 
         # This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
@@ -518,118 +433,119 @@ module OpenAI
 
         sig do
           params(
+
             background: T.nilable(T::Boolean),
-            context_management:
-              T.nilable(
-                T::Array[
-                  OpenAI::Responses::ResponsesClientEvent::ContextManagement::OrHash
-                ]
-              ),
-            conversation:
-              T.nilable(
-                T.any(
-                  String,
-                  OpenAI::Responses::ResponseConversationParam::OrHash
-                )
-              ),
-            include:
-              T.nilable(
-                T::Array[OpenAI::Responses::ResponseIncludable::OrSymbol]
-              ),
+
+            context_management: T.nilable(T::Array[OpenAI::Responses::ResponsesClientEvent::ContextManagement::OrHash]),
+
+            conversation: T.nilable(T.any(String, OpenAI::Responses::ResponseConversationParam::OrHash)),
+
+            include: T.nilable(T::Array[OpenAI::Responses::ResponseIncludable::OrSymbol]),
+
             input: OpenAI::Responses::ResponsesClientEvent::Input::Variants,
+
             instructions: T.nilable(String),
+
             max_output_tokens: T.nilable(Integer),
+
             max_tool_calls: T.nilable(Integer),
+
             metadata: T.nilable(T::Hash[Symbol, String]),
-            model:
-              T.any(
-                String,
-                OpenAI::ChatModel::OrSymbol,
-                OpenAI::ResponsesModel::ResponsesOnlyModel::OrSymbol
-              ),
-            moderation:
-              T.nilable(
-                OpenAI::Responses::ResponsesClientEvent::Moderation::OrHash
-              ),
+
+            model: T.any(String, OpenAI::ChatModel::OrSymbol, OpenAI::ResponsesModel::ResponsesOnlyModel::OrSymbol),
+
+            moderation: T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::OrHash),
+
             parallel_tool_calls: T.nilable(T::Boolean),
+
             previous_response_id: T.nilable(String),
+
             prompt: T.nilable(OpenAI::Responses::ResponsePrompt::OrHash),
+
             prompt_cache_key: T.nilable(String),
-            prompt_cache_options:
-              OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::OrHash,
-            prompt_cache_retention:
-              T.nilable(
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention::OrSymbol
-              ),
+
+            prompt_cache_options: OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::OrHash,
+
+            prompt_cache_retention: T.nilable(OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention::OrSymbol),
+
             reasoning: T.nilable(OpenAI::Reasoning::OrHash),
+
             safety_identifier: T.nilable(String),
-            service_tier:
-              T.nilable(
-                OpenAI::Responses::ResponsesClientEvent::ServiceTier::OrSymbol
-              ),
+
+            service_tier: T.nilable(OpenAI::Responses::ResponsesClientEvent::ServiceTier::OrSymbol),
+
             store: T.nilable(T::Boolean),
+
             stream: T.nilable(T::Boolean),
+
             stream_id: String,
-            stream_options:
-              T.nilable(
-                OpenAI::Responses::ResponsesClientEvent::StreamOptions::OrHash
-              ),
+
+            stream_options: T.nilable(OpenAI::Responses::ResponsesClientEvent::StreamOptions::OrHash),
+
             temperature: T.nilable(Float),
+
             text: OpenAI::Responses::ResponseTextConfig::OrHash,
-            tool_choice:
+
+            tool_choice: T.any(
+              OpenAI::Responses::ToolChoiceOptions::OrSymbol,
+              OpenAI::Responses::ToolChoiceAllowed::OrHash,
+              OpenAI::Responses::ToolChoiceTypes::OrHash,
+              OpenAI::Responses::ToolChoiceFunction::OrHash,
+              OpenAI::Responses::ToolChoiceMcp::OrHash,
+              OpenAI::Responses::ToolChoiceCustom::OrHash,
+              OpenAI::Responses::ResponsesClientEvent::ToolChoice::SpecificProgrammaticToolCallingParam::OrHash,
+              OpenAI::Responses::ToolChoiceApplyPatch::OrHash,
+              OpenAI::Responses::ToolChoiceShell::OrHash
+            ),
+
+            tools: T::Array[
               T.any(
-                OpenAI::Responses::ToolChoiceOptions::OrSymbol,
-                OpenAI::Responses::ToolChoiceAllowed::OrHash,
-                OpenAI::Responses::ToolChoiceTypes::OrHash,
-                OpenAI::Responses::ToolChoiceFunction::OrHash,
-                OpenAI::Responses::ToolChoiceMcp::OrHash,
-                OpenAI::Responses::ToolChoiceCustom::OrHash,
-                OpenAI::Responses::ResponsesClientEvent::ToolChoice::SpecificProgrammaticToolCallingParam::OrHash,
-                OpenAI::Responses::ToolChoiceApplyPatch::OrHash,
-                OpenAI::Responses::ToolChoiceShell::OrHash
-              ),
-            tools:
-              T::Array[
-                T.any(
-                  OpenAI::Responses::FunctionTool::OrHash,
-                  OpenAI::Responses::FileSearchTool::OrHash,
-                  OpenAI::Responses::ComputerTool::OrHash,
-                  OpenAI::Responses::ComputerUsePreviewTool::OrHash,
-                  OpenAI::Responses::Tool::Mcp::OrHash,
-                  OpenAI::Responses::Tool::CodeInterpreter::OrHash,
-                  OpenAI::Responses::Tool::ProgrammaticToolCalling::OrHash,
-                  OpenAI::Responses::Tool::ImageGeneration::OrHash,
-                  OpenAI::Responses::Tool::LocalShell::OrHash,
-                  OpenAI::Responses::FunctionShellTool::OrHash,
-                  OpenAI::Responses::CustomTool::OrHash,
-                  OpenAI::Responses::NamespaceTool::OrHash,
-                  OpenAI::Responses::ToolSearchTool::OrHash,
-                  OpenAI::Responses::ApplyPatchTool::OrHash,
-                  OpenAI::Responses::WebSearchTool::OrHash,
-                  OpenAI::Responses::WebSearchPreviewTool::OrHash
-                )
-              ],
+                OpenAI::Responses::FunctionTool::OrHash,
+                OpenAI::Responses::FileSearchTool::OrHash,
+                OpenAI::Responses::ComputerTool::OrHash,
+                OpenAI::Responses::ComputerUsePreviewTool::OrHash,
+                OpenAI::Responses::Tool::Mcp::OrHash,
+                OpenAI::Responses::Tool::CodeInterpreter::OrHash,
+                OpenAI::Responses::Tool::ProgrammaticToolCalling::OrHash,
+                OpenAI::Responses::Tool::ImageGeneration::OrHash,
+                OpenAI::Responses::Tool::LocalShell::OrHash,
+                OpenAI::Responses::FunctionShellTool::OrHash,
+                OpenAI::Responses::CustomTool::OrHash,
+                OpenAI::Responses::NamespaceTool::OrHash,
+                OpenAI::Responses::ToolSearchTool::OrHash,
+                OpenAI::Responses::ApplyPatchTool::OrHash,
+                OpenAI::Responses::WebSearchTool::OrHash,
+                OpenAI::Responses::WebSearchPreviewTool::OrHash
+              )
+            ],
+
             top_logprobs: T.nilable(Integer),
+
             top_p: T.nilable(Float),
-            truncation:
-              T.nilable(
-                OpenAI::Responses::ResponsesClientEvent::Truncation::OrSymbol
-              ),
+
+            truncation: T.nilable(OpenAI::Responses::ResponsesClientEvent::Truncation::OrSymbol),
+
             user: String,
+
             type: Symbol
-          ).returns(T.attached_class)
+          )
+            .returns(T.attached_class)
         end
         def self.new(
+
           # Whether to run the model response in the background.
           # [Learn more](https://platform.openai.com/docs/guides/background).
           background: nil,
+
           # Context management configuration for this request.
           context_management: nil,
+
           # The conversation that this response belongs to. Items from this conversation are
           # prepended to `input_items` for this response request. Input items and output
           # items from this response are automatically added to this conversation after this
           # response completes.
           conversation: nil,
+
           # Specify additional output data to include in the model response. Currently
           # supported values are:
           #
@@ -649,6 +565,7 @@ module OpenAI
           #   the `store` parameter is set to `false`, or when an organization is enrolled
           #   in the zero data retention program).
           include: nil,
+
           # Text, image, or file inputs to the model, used to generate a response.
           #
           # Learn more:
@@ -659,21 +576,25 @@ module OpenAI
           # - [Conversation state](https://platform.openai.com/docs/guides/conversation-state)
           # - [Function calling](https://platform.openai.com/docs/guides/function-calling)
           input: nil,
+
           # A system (or developer) message inserted into the model's context.
           #
           # When using along with `previous_response_id`, the instructions from a previous
           # response will not be carried over to the next response. This makes it simple to
           # swap out system (or developer) messages in new responses.
           instructions: nil,
+
           # An upper bound for the number of tokens that can be generated for a response,
           # including visible output tokens and
           # [reasoning tokens](https://platform.openai.com/docs/guides/reasoning).
           max_output_tokens: nil,
+
           # The maximum number of total calls to built-in tools that can be processed in a
           # response. This maximum number applies across all built-in tool calls, not per
           # individual tool. Any further attempts to call a tool by the model will be
           # ignored.
           max_tool_calls: nil,
+
           # Set of 16 key-value pairs that can be attached to an object. This can be useful
           # for storing additional information about the object in a structured format, and
           # querying for objects via API or the dashboard.
@@ -681,28 +602,35 @@ module OpenAI
           # Keys are strings with a maximum length of 64 characters. Values are strings with
           # a maximum length of 512 characters.
           metadata: nil,
+
           # Model ID used to generate the response, like `gpt-4o` or `o3`. OpenAI offers a
           # wide range of models with different capabilities, performance characteristics,
           # and price points. Refer to the
           # [model guide](https://platform.openai.com/docs/models) to browse and compare
           # available models.
           model: nil,
+
           # Configuration for running moderation on the input and output of this response.
           moderation: nil,
+
           # Whether to allow the model to run tool calls in parallel.
           parallel_tool_calls: nil,
+
           # The unique ID of the previous response to the model. Use this to create
           # multi-turn conversations. Learn more about
           # [conversation state](https://platform.openai.com/docs/guides/conversation-state).
           # Cannot be used in conjunction with `conversation`.
           previous_response_id: nil,
+
           # Reference to a prompt template and its variables.
           # [Learn more](https://platform.openai.com/docs/guides/text?api-mode=responses#reusable-prompts).
           prompt: nil,
+
           # Used by OpenAI to cache responses for similar requests to optimize your cache
           # hit rates. Replaces the `user` field.
           # [Learn more](https://platform.openai.com/docs/guides/prompt-caching).
           prompt_cache_key: nil,
+
           # Options for prompt caching. Supported for `gpt-5.6` and later models. By
           # default, OpenAI automatically chooses one implicit cache breakpoint. You can add
           # explicit breakpoints to content blocks with `prompt_cache_breakpoint`. Each
@@ -713,6 +641,7 @@ module OpenAI
           # [prompt caching guide](https://platform.openai.com/docs/guides/prompt-caching)
           # for current details.
           prompt_cache_options: nil,
+
           # Deprecated. Use `prompt_cache_options.ttl` instead.
           #
           # The retention policy for the prompt cache. Set to `24h` to enable extended
@@ -731,11 +660,13 @@ module OpenAI
           # - Organizations with ZDR enabled default to `in_memory` when
           #   `prompt_cache_retention` is not specified.
           prompt_cache_retention: nil,
+
           # **gpt-5 and o-series models only**
           #
           # Configuration options for
           # [reasoning models](https://platform.openai.com/docs/guides/reasoning).
           reasoning: nil,
+
           # A stable identifier used to help detect users of your application that may be
           # violating OpenAI's usage policies. The IDs should be a string that uniquely
           # identifies each user, with a maximum length of 64 characters. We recommend
@@ -743,6 +674,7 @@ module OpenAI
           # identifying information.
           # [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
           safety_identifier: nil,
+
           # Specifies the processing type used for serving the request.
           #
           # - If set to 'auto', then the request will be processed with the service tier
@@ -757,6 +689,10 @@ module OpenAI
           #   Responses or Chat Completions. The response will show `service_tier=priority`
           #   regardless of if you specify `service_tier=fast` or `priority` in your
           #   request.
+          # - If set to 'ultrafast', then the request will be processed with the
+          #   access-controlled Ultrafast Processing service tier. This tier is currently
+          #   available for `gpt-5.6-sol`; a response served through it will show
+          #   `service_tier=ultrafast`.
           # - When not set, the default behavior is 'auto'.
           #
           # When the `service_tier` parameter is set, the response body will include the
@@ -764,8 +700,10 @@ module OpenAI
           # request. This response value may be different from the value set in the
           # parameter.
           service_tier: nil,
+
           # Whether to store the generated model response for later retrieval via API.
           store: nil,
+
           # If set to true, the model response data will be streamed to the client as it is
           # generated using
           # [server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#Event_stream_format).
@@ -773,29 +711,35 @@ module OpenAI
           # [Streaming section below](https://platform.openai.com/docs/api-reference/responses-streaming)
           # for more information.
           stream: nil,
+
           # The WebSocket lane for this response. Requests with the same `stream_id` are
           # processed FIFO, and events for the response echo the same `stream_id`.
           #
           # `stream_id` controls routing; `previous_response_id` controls conversation
           # lineage, so a new lane can fork from a response created on another lane.
           stream_id: nil,
+
           # Options for streaming responses. Only set this when you set `stream: true`.
           stream_options: nil,
+
           # What sampling temperature to use, between 0 and 2. Higher values like 0.8 will
           # make the output more random, while lower values like 0.2 will make it more
           # focused and deterministic. We generally recommend altering this or `top_p` but
           # not both.
           temperature: nil,
+
           # Configuration options for a text response from the model. Can be plain text or
           # structured JSON data. Learn more:
           #
           # - [Text inputs and outputs](https://platform.openai.com/docs/guides/text)
           # - [Structured Outputs](https://platform.openai.com/docs/guides/structured-outputs)
           text: nil,
+
           # How the model should select which tool (or tools) to use when generating a
           # response. See the `tools` parameter to see how to specify which tools the model
           # can call.
           tool_choice: nil,
+
           # An array of tools the model may call while generating a response. You can
           # specify which tool to use by setting the `tool_choice` parameter.
           #
@@ -816,16 +760,19 @@ module OpenAI
           #   [function calling](https://platform.openai.com/docs/guides/function-calling).
           #   You can also use custom tools to call your own code.
           tools: nil,
+
           # An integer between 0 and 20 specifying the maximum number of most likely tokens
           # to return at each token position, each with an associated log probability. In
           # some cases, the number of returned tokens may be fewer than requested.
           top_logprobs: nil,
+
           # An alternative to sampling with temperature, called nucleus sampling, where the
           # model considers the results of the tokens with top_p probability mass. So 0.1
           # means only the tokens comprising the top 10% probability mass are considered.
           #
           # We generally recommend altering this or `temperature` but not both.
           top_p: nil,
+
           # The truncation strategy to use for the model response.
           #
           # - `auto`: If the input to this Response exceeds the model's context window size,
@@ -834,13 +781,16 @@ module OpenAI
           # - `disabled` (default): If the input size will exceed the context window size
           #   for a model, the request will fail with a 400 error.
           truncation: nil,
+
           # This field is being replaced by `safety_identifier` and `prompt_cache_key`. Use
           # `prompt_cache_key` instead to maintain caching optimizations. A stable
           # identifier for your end-users. Used to boost cache hit rates by better bucketing
           # similar requests and to help OpenAI detect and prevent abuse.
           # [Learn more](https://platform.openai.com/docs/guides/safety-best-practices#safety-identifiers).
           user: nil,
+
           # The type of the client event. Always `response.create`.
+
           type: :"response.create"
         )
         end
@@ -850,97 +800,65 @@ module OpenAI
             {
               type: Symbol,
               background: T.nilable(T::Boolean),
-              context_management:
-                T.nilable(
-                  T::Array[
-                    OpenAI::Responses::ResponsesClientEvent::ContextManagement
-                  ]
-                ),
-              conversation:
-                T.nilable(
-                  T.any(String, OpenAI::Responses::ResponseConversationParam)
-                ),
-              include:
-                T.nilable(
-                  T::Array[OpenAI::Responses::ResponseIncludable::OrSymbol]
-                ),
+              context_management: T.nilable(T::Array[OpenAI::Responses::ResponsesClientEvent::ContextManagement]),
+              conversation: T.nilable(T.any(String, OpenAI::Responses::ResponseConversationParam)),
+              include: T.nilable(T::Array[OpenAI::Responses::ResponseIncludable::OrSymbol]),
               input: OpenAI::Responses::ResponsesClientEvent::Input::Variants,
               instructions: T.nilable(String),
               max_output_tokens: T.nilable(Integer),
               max_tool_calls: T.nilable(Integer),
               metadata: T.nilable(T::Hash[Symbol, String]),
-              model:
-                T.any(
-                  String,
-                  OpenAI::ChatModel::OrSymbol,
-                  OpenAI::ResponsesModel::ResponsesOnlyModel::OrSymbol
-                ),
-              moderation:
-                T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation),
+              model: T.any(String, OpenAI::ChatModel::OrSymbol, OpenAI::ResponsesModel::ResponsesOnlyModel::OrSymbol),
+              moderation: T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation),
               parallel_tool_calls: T.nilable(T::Boolean),
               previous_response_id: T.nilable(String),
               prompt: T.nilable(OpenAI::Responses::ResponsePrompt),
               prompt_cache_key: T.nilable(String),
-              prompt_cache_options:
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions,
-              prompt_cache_retention:
-                T.nilable(
-                  OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention::OrSymbol
-                ),
+              prompt_cache_options: OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions,
+              prompt_cache_retention: T.nilable(OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention::OrSymbol),
               reasoning: T.nilable(OpenAI::Reasoning),
               safety_identifier: T.nilable(String),
-              service_tier:
-                T.nilable(
-                  OpenAI::Responses::ResponsesClientEvent::ServiceTier::OrSymbol
-                ),
+              service_tier: T.nilable(OpenAI::Responses::ResponsesClientEvent::ServiceTier::OrSymbol),
               store: T.nilable(T::Boolean),
               stream: T.nilable(T::Boolean),
               stream_id: String,
-              stream_options:
-                T.nilable(
-                  OpenAI::Responses::ResponsesClientEvent::StreamOptions
-                ),
+              stream_options: T.nilable(OpenAI::Responses::ResponsesClientEvent::StreamOptions),
               temperature: T.nilable(Float),
               text: OpenAI::Responses::ResponseTextConfig,
-              tool_choice:
+              tool_choice: T.any(
+                OpenAI::Responses::ToolChoiceOptions::OrSymbol,
+                OpenAI::Responses::ToolChoiceAllowed,
+                OpenAI::Responses::ToolChoiceTypes,
+                OpenAI::Responses::ToolChoiceFunction,
+                OpenAI::Responses::ToolChoiceMcp,
+                OpenAI::Responses::ToolChoiceCustom,
+                OpenAI::Responses::ResponsesClientEvent::ToolChoice::SpecificProgrammaticToolCallingParam,
+                OpenAI::Responses::ToolChoiceApplyPatch,
+                OpenAI::Responses::ToolChoiceShell
+              ),
+              tools: T::Array[
                 T.any(
-                  OpenAI::Responses::ToolChoiceOptions::OrSymbol,
-                  OpenAI::Responses::ToolChoiceAllowed,
-                  OpenAI::Responses::ToolChoiceTypes,
-                  OpenAI::Responses::ToolChoiceFunction,
-                  OpenAI::Responses::ToolChoiceMcp,
-                  OpenAI::Responses::ToolChoiceCustom,
-                  OpenAI::Responses::ResponsesClientEvent::ToolChoice::SpecificProgrammaticToolCallingParam,
-                  OpenAI::Responses::ToolChoiceApplyPatch,
-                  OpenAI::Responses::ToolChoiceShell
-                ),
-              tools:
-                T::Array[
-                  T.any(
-                    OpenAI::Responses::FunctionTool,
-                    OpenAI::Responses::FileSearchTool,
-                    OpenAI::Responses::ComputerTool,
-                    OpenAI::Responses::ComputerUsePreviewTool,
-                    OpenAI::Responses::Tool::Mcp,
-                    OpenAI::Responses::Tool::CodeInterpreter,
-                    OpenAI::Responses::Tool::ProgrammaticToolCalling,
-                    OpenAI::Responses::Tool::ImageGeneration,
-                    OpenAI::Responses::Tool::LocalShell,
-                    OpenAI::Responses::FunctionShellTool,
-                    OpenAI::Responses::CustomTool,
-                    OpenAI::Responses::NamespaceTool,
-                    OpenAI::Responses::ToolSearchTool,
-                    OpenAI::Responses::ApplyPatchTool,
-                    OpenAI::Responses::WebSearchTool,
-                    OpenAI::Responses::WebSearchPreviewTool
-                  )
-                ],
+                  OpenAI::Responses::FunctionTool,
+                  OpenAI::Responses::FileSearchTool,
+                  OpenAI::Responses::ComputerTool,
+                  OpenAI::Responses::ComputerUsePreviewTool,
+                  OpenAI::Responses::Tool::Mcp,
+                  OpenAI::Responses::Tool::CodeInterpreter,
+                  OpenAI::Responses::Tool::ProgrammaticToolCalling,
+                  OpenAI::Responses::Tool::ImageGeneration,
+                  OpenAI::Responses::Tool::LocalShell,
+                  OpenAI::Responses::FunctionShellTool,
+                  OpenAI::Responses::CustomTool,
+                  OpenAI::Responses::NamespaceTool,
+                  OpenAI::Responses::ToolSearchTool,
+                  OpenAI::Responses::ApplyPatchTool,
+                  OpenAI::Responses::WebSearchTool,
+                  OpenAI::Responses::WebSearchPreviewTool
+                )
+              ],
               top_logprobs: T.nilable(Integer),
               top_p: T.nilable(Float),
-              truncation:
-                T.nilable(
-                  OpenAI::Responses::ResponsesClientEvent::Truncation::OrSymbol
-                ),
+              truncation: T.nilable(OpenAI::Responses::ResponsesClientEvent::Truncation::OrSymbol),
               user: String
             }
           )
@@ -949,13 +867,12 @@ module OpenAI
         end
 
         class ContextManagement < OpenAI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                OpenAI::Responses::ResponsesClientEvent::ContextManagement,
-                OpenAI::Internal::AnyHash
-              )
-            end
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponsesClientEvent::ContextManagement,
+              OpenAI::Internal::AnyHash
+            )
+          end
 
           # The context management entry type. Currently only 'compaction' is supported.
           sig { returns(String) }
@@ -966,25 +883,33 @@ module OpenAI
           attr_accessor :compact_threshold
 
           sig do
-            params(type: String, compact_threshold: T.nilable(Integer)).returns(
-              T.attached_class
+            params(
+
+              type: String,
+
+              compact_threshold: T.nilable(Integer)
             )
+              .returns(T.attached_class)
           end
           def self.new(
+
             # The context management entry type. Currently only 'compaction' is supported.
             type:,
+
             # Token threshold at which compaction should be triggered for this entry.
+
             compact_threshold: nil
           )
           end
 
           sig do
             override.returns(
-              { type: String, compact_threshold: T.nilable(Integer) }
+              {type: String, compact_threshold: T.nilable(Integer)}
             )
           end
           def to_hash
           end
+
         end
 
         # The conversation that this response belongs to. Items from this conversation are
@@ -994,20 +919,12 @@ module OpenAI
         module Conversation
           extend OpenAI::Internal::Type::Union
 
-          Variants =
-            T.type_alias do
-              T.any(String, OpenAI::Responses::ResponseConversationParam)
-            end
+          Variants = T.type_alias { T.any(String, OpenAI::Responses::ResponseConversationParam) }
 
-          sig do
-            override.returns(
-              T::Array[
-                OpenAI::Responses::ResponsesClientEvent::Conversation::Variants
-              ]
-            )
-          end
+          sig { override.returns(T::Array[OpenAI::Responses::ResponsesClientEvent::Conversation::Variants]) }
           def self.variants
           end
+
         end
 
         # Text, image, or file inputs to the model, used to generate a response.
@@ -1022,31 +939,21 @@ module OpenAI
         module Input
           extend OpenAI::Internal::Type::Union
 
-          Variants =
-            T.type_alias do
-              T.any(
-                String,
-                T::Array[OpenAI::Responses::ResponseInputItem::Variants]
-              )
-            end
+          Variants = T.type_alias { T.any(String, T::Array[OpenAI::Responses::ResponseInputItem::Variants]) }
 
-          sig do
-            override.returns(
-              T::Array[OpenAI::Responses::ResponsesClientEvent::Input::Variants]
-            )
-          end
+          sig { override.returns(T::Array[OpenAI::Responses::ResponsesClientEvent::Input::Variants]) }
           def self.variants
           end
+
         end
 
         class Moderation < OpenAI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                OpenAI::Responses::ResponsesClientEvent::Moderation,
-                OpenAI::Internal::AnyHash
-              )
-            end
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponsesClientEvent::Moderation,
+              OpenAI::Internal::AnyHash
+            )
+          end
 
           # The moderation model to use for moderated completions, e.g.
           # 'omni-moderation-latest'.
@@ -1054,124 +961,86 @@ module OpenAI
           attr_accessor :model
 
           # The policy to apply to moderated response input and output.
-          sig do
-            returns(
-              T.nilable(
-                OpenAI::Responses::ResponsesClientEvent::Moderation::Policy
-              )
-            )
-          end
+          sig { returns(T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy)) }
           attr_reader :policy
 
-          sig do
-            params(
-              policy:
-                T.nilable(
-                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::OrHash
-                )
-            ).void
-          end
+          sig { params(policy: T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::OrHash)).void }
           attr_writer :policy
 
           # Configuration for running moderation on the input and output of this response.
           sig do
             params(
+
               model: String,
-              policy:
-                T.nilable(
-                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::OrHash
-                )
-            ).returns(T.attached_class)
+
+              policy: T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::OrHash)
+            )
+              .returns(T.attached_class)
           end
           def self.new(
+
             # The moderation model to use for moderated completions, e.g.
             # 'omni-moderation-latest'.
             model:,
+
             # The policy to apply to moderated response input and output.
+
             policy: nil
           )
           end
 
           sig do
             override.returns(
-              {
-                model: String,
-                policy:
-                  T.nilable(
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy
-                  )
-              }
+              {model: String, policy: T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy)}
             )
           end
           def to_hash
           end
 
           class Policy < OpenAI::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy,
-                  OpenAI::Internal::AnyHash
-                )
-              end
-
-            # The moderation policy for the response input.
-            sig do
-              returns(
-                T.nilable(
-                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input
-                )
+            OrHash = T.type_alias do
+              T.any(
+                OpenAI::Responses::ResponsesClientEvent::Moderation::Policy,
+                OpenAI::Internal::AnyHash
               )
             end
+
+            # The moderation policy for the response input.
+            sig { returns(T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input)) }
             attr_reader :input
 
-            sig do
-              params(
-                input:
-                  T.nilable(
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::OrHash
-                  )
-              ).void
-            end
+            sig {
+              params(input: T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::OrHash)).void
+            }
             attr_writer :input
 
             # The moderation policy for the response output.
-            sig do
-              returns(
-                T.nilable(
-                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output
-                )
-              )
-            end
+            sig { returns(T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output)) }
             attr_reader :output
 
-            sig do
-              params(
-                output:
-                  T.nilable(
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::OrHash
-                  )
-              ).void
-            end
+            sig {
+              params(output: T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::OrHash))
+                .void
+            }
             attr_writer :output
 
             # The policy to apply to moderated response input and output.
             sig do
               params(
-                input:
-                  T.nilable(
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::OrHash
-                  ),
-                output:
-                  T.nilable(
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::OrHash
-                  )
-              ).returns(T.attached_class)
+
+                input: T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::OrHash),
+
+                output: T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::OrHash)
+              )
+                .returns(T.attached_class)
             end
             def self.new(
+
               # The moderation policy for the response input.
               input: nil,
+
               # The moderation policy for the response output.
+
               output: nil
             )
             end
@@ -1179,14 +1048,8 @@ module OpenAI
             sig do
               override.returns(
                 {
-                  input:
-                    T.nilable(
-                      OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input
-                    ),
-                  output:
-                    T.nilable(
-                      OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output
-                    )
+                  input: T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input),
+                  output: T.nilable(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output)
                 }
               )
             end
@@ -1194,37 +1057,33 @@ module OpenAI
             end
 
             class Input < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input,
-                    OpenAI::Internal::AnyHash
-                  )
-                end
-
-              sig do
-                returns(
-                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode::OrSymbol
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input,
+                  OpenAI::Internal::AnyHash
                 )
               end
+
+              sig { returns(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode::OrSymbol) }
               attr_accessor :mode
 
               # The moderation policy for the response input.
               sig do
                 params(
-                  mode:
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode::OrSymbol
-                ).returns(T.attached_class)
+
+                  mode: OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode::OrSymbol
+                )
+                  .returns(T.attached_class)
               end
-              def self.new(mode:)
+              def self.new(
+
+                mode:
+              )
               end
 
               sig do
                 override.returns(
-                  {
-                    mode:
-                      OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode::OrSymbol
-                  }
+                  {mode: OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode::OrSymbol}
                 )
               end
               def to_hash
@@ -1233,70 +1092,58 @@ module OpenAI
               module Mode
                 extend OpenAI::Internal::Type::Enum
 
-                TaggedSymbol =
-                  T.type_alias do
-                    T.all(
-                      Symbol,
-                      OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode
-                    )
-                  end
+                TaggedSymbol = T.type_alias {
+                  T.all(Symbol, OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode)
+                }
                 OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-                SCORE =
-                  T.let(
-                    :score,
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode::TaggedSymbol
-                  )
-                BLOCK =
-                  T.let(
-                    :block,
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode::TaggedSymbol
-                  )
+                SCORE = T.let(
+                  :score,
+                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode::TaggedSymbol
+                )
+                BLOCK = T.let(
+                  :block,
+                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode::TaggedSymbol
+                )
 
-                sig do
+                sig {
                   override.returns(
-                    T::Array[
-                      OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode::TaggedSymbol
-                    ]
+                    T::Array[OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Input::Mode::TaggedSymbol]
                   )
-                end
+                }
                 def self.values
                 end
               end
             end
 
             class Output < OpenAI::Internal::Type::BaseModel
-              OrHash =
-                T.type_alias do
-                  T.any(
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output,
-                    OpenAI::Internal::AnyHash
-                  )
-                end
-
-              sig do
-                returns(
-                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode::OrSymbol
+              OrHash = T.type_alias do
+                T.any(
+                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output,
+                  OpenAI::Internal::AnyHash
                 )
               end
+
+              sig { returns(OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode::OrSymbol) }
               attr_accessor :mode
 
               # The moderation policy for the response output.
               sig do
                 params(
-                  mode:
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode::OrSymbol
-                ).returns(T.attached_class)
+
+                  mode: OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode::OrSymbol
+                )
+                  .returns(T.attached_class)
               end
-              def self.new(mode:)
+              def self.new(
+
+                mode:
+              )
               end
 
               sig do
                 override.returns(
-                  {
-                    mode:
-                      OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode::OrSymbol
-                  }
+                  {mode: OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode::OrSymbol}
                 )
               end
               def to_hash
@@ -1305,33 +1152,25 @@ module OpenAI
               module Mode
                 extend OpenAI::Internal::Type::Enum
 
-                TaggedSymbol =
-                  T.type_alias do
-                    T.all(
-                      Symbol,
-                      OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode
-                    )
-                  end
+                TaggedSymbol = T.type_alias {
+                  T.all(Symbol, OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode)
+                }
                 OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-                SCORE =
-                  T.let(
-                    :score,
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode::TaggedSymbol
-                  )
-                BLOCK =
-                  T.let(
-                    :block,
-                    OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode::TaggedSymbol
-                  )
+                SCORE = T.let(
+                  :score,
+                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode::TaggedSymbol
+                )
+                BLOCK = T.let(
+                  :block,
+                  OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode::TaggedSymbol
+                )
 
-                sig do
+                sig {
                   override.returns(
-                    T::Array[
-                      OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode::TaggedSymbol
-                    ]
+                    T::Array[OpenAI::Responses::ResponsesClientEvent::Moderation::Policy::Output::Mode::TaggedSymbol]
                   )
-                end
+                }
                 def self.values
                 end
               end
@@ -1340,13 +1179,12 @@ module OpenAI
         end
 
         class PromptCacheOptions < OpenAI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions,
-                OpenAI::Internal::AnyHash
-              )
-            end
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions,
+              OpenAI::Internal::AnyHash
+            )
+          end
 
           # Controls whether OpenAI automatically creates an implicit cache breakpoint.
           # Defaults to `implicit`. With `implicit`, OpenAI creates one implicit breakpoint
@@ -1354,41 +1192,19 @@ module OpenAI
           # `explicit`, OpenAI does not create an implicit breakpoint and writes up to the
           # latest four explicit breakpoints. If there are no explicit breakpoints, the
           # request does not use prompt caching.
-          sig do
-            returns(
-              T.nilable(
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::OrSymbol
-              )
-            )
-          end
+          sig { returns(T.nilable(OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::OrSymbol)) }
           attr_reader :mode
 
-          sig do
-            params(
-              mode:
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::OrSymbol
-            ).void
-          end
+          sig { params(mode: OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::OrSymbol).void }
           attr_writer :mode
 
           # The minimum lifetime applied to every implicit and explicit cache breakpoint
           # written by the request. Defaults to `30m`, which is currently the only supported
           # value. The backend may retain cache entries for longer.
-          sig do
-            returns(
-              T.nilable(
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl::OrSymbol
-              )
-            )
-          end
+          sig { returns(T.nilable(OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl::OrSymbol)) }
           attr_reader :ttl
 
-          sig do
-            params(
-              ttl:
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl::OrSymbol
-            ).void
-          end
+          sig { params(ttl: OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl::OrSymbol).void }
           attr_writer :ttl
 
           # Options for prompt caching. Supported for `gpt-5.6` and later models. By
@@ -1402,13 +1218,15 @@ module OpenAI
           # for current details.
           sig do
             params(
-              mode:
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::OrSymbol,
-              ttl:
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl::OrSymbol
-            ).returns(T.attached_class)
+
+              mode: OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::OrSymbol,
+
+              ttl: OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl::OrSymbol
+            )
+              .returns(T.attached_class)
           end
           def self.new(
+
             # Controls whether OpenAI automatically creates an implicit cache breakpoint.
             # Defaults to `implicit`. With `implicit`, OpenAI creates one implicit breakpoint
             # and writes up to the latest three explicit breakpoints in the request. With
@@ -1416,9 +1234,11 @@ module OpenAI
             # latest four explicit breakpoints. If there are no explicit breakpoints, the
             # request does not use prompt caching.
             mode: nil,
+
             # The minimum lifetime applied to every implicit and explicit cache breakpoint
             # written by the request. Defaults to `30m`, which is currently the only supported
             # value. The backend may retain cache entries for longer.
+
             ttl: nil
           )
           end
@@ -1426,10 +1246,8 @@ module OpenAI
           sig do
             override.returns(
               {
-                mode:
-                  OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::OrSymbol,
-                ttl:
-                  OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl::OrSymbol
+                mode: OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::OrSymbol,
+                ttl: OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl::OrSymbol
               }
             )
           end
@@ -1445,33 +1263,19 @@ module OpenAI
           module Mode
             extend OpenAI::Internal::Type::Enum
 
-            TaggedSymbol =
-              T.type_alias do
-                T.all(
-                  Symbol,
-                  OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode
-                )
-              end
+            TaggedSymbol = T.type_alias {
+              T.all(Symbol, OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode)
+            }
             OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-            IMPLICIT =
-              T.let(
-                :implicit,
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::TaggedSymbol
-              )
-            EXPLICIT =
-              T.let(
-                :explicit,
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::TaggedSymbol
-              )
+            IMPLICIT = T.let(:implicit, OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::TaggedSymbol)
+            EXPLICIT = T.let(:explicit, OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::TaggedSymbol)
 
-            sig do
+            sig {
               override.returns(
-                T::Array[
-                  OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::TaggedSymbol
-                ]
+                T::Array[OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Mode::TaggedSymbol]
               )
-            end
+            }
             def self.values
             end
           end
@@ -1482,28 +1286,16 @@ module OpenAI
           module Ttl
             extend OpenAI::Internal::Type::Enum
 
-            TaggedSymbol =
-              T.type_alias do
-                T.all(
-                  Symbol,
-                  OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl
-                )
-              end
+            TaggedSymbol = T.type_alias {
+              T.all(Symbol, OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl)
+            }
             OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-            TTL_30M =
-              T.let(
-                :"30m",
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl::TaggedSymbol
-              )
+            TTL_30M = T.let(:"30m", OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl::TaggedSymbol)
 
-            sig do
-              override.returns(
-                T::Array[
-                  OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl::TaggedSymbol
-                ]
-              )
-            end
+            sig {
+              override.returns(T::Array[OpenAI::Responses::ResponsesClientEvent::PromptCacheOptions::Ttl::TaggedSymbol])
+            }
             def self.values
             end
           end
@@ -1529,33 +1321,18 @@ module OpenAI
         module PromptCacheRetention
           extend OpenAI::Internal::Type::Enum
 
-          TaggedSymbol =
-            T.type_alias do
-              T.all(
-                Symbol,
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention
-              )
-            end
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention) }
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          IN_MEMORY =
-            T.let(
-              :in_memory,
-              OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention::TaggedSymbol
-            )
-          PROMPT_CACHE_RETENTION_24H =
-            T.let(
-              :"24h",
-              OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention::TaggedSymbol
-            )
+          IN_MEMORY = T.let(:in_memory, OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention::TaggedSymbol)
+          PROMPT_CACHE_RETENTION_24H = T.let(
+            :"24h",
+            OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention::TaggedSymbol
+          )
 
-          sig do
-            override.returns(
-              T::Array[
-                OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention::TaggedSymbol
-              ]
-            )
-          end
+          sig {
+            override.returns(T::Array[OpenAI::Responses::ResponsesClientEvent::PromptCacheRetention::TaggedSymbol])
+          }
           def self.values
           end
         end
@@ -1574,6 +1351,10 @@ module OpenAI
         #   Responses or Chat Completions. The response will show `service_tier=priority`
         #   regardless of if you specify `service_tier=fast` or `priority` in your
         #   request.
+        # - If set to 'ultrafast', then the request will be processed with the
+        #   access-controlled Ultrafast Processing service tier. This tier is currently
+        #   available for `gpt-5.6-sol`; a response served through it will show
+        #   `service_tier=ultrafast`.
         # - When not set, the default behavior is 'auto'.
         #
         # When the `service_tier` parameter is set, the response body will include the
@@ -1583,65 +1364,29 @@ module OpenAI
         module ServiceTier
           extend OpenAI::Internal::Type::Enum
 
-          TaggedSymbol =
-            T.type_alias do
-              T.all(
-                Symbol,
-                OpenAI::Responses::ResponsesClientEvent::ServiceTier
-              )
-            end
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Responses::ResponsesClientEvent::ServiceTier) }
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          AUTO =
-            T.let(
-              :auto,
-              OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol
-            )
-          DEFAULT =
-            T.let(
-              :default,
-              OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol
-            )
-          FLEX =
-            T.let(
-              :flex,
-              OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol
-            )
-          SCALE =
-            T.let(
-              :scale,
-              OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol
-            )
-          PRIORITY =
-            T.let(
-              :priority,
-              OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol
-            )
-          FAST =
-            T.let(
-              :fast,
-              OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol
-            )
+          AUTO = T.let(:auto, OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol)
+          DEFAULT = T.let(:default, OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol)
+          FLEX = T.let(:flex, OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol)
+          SCALE = T.let(:scale, OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol)
+          PRIORITY = T.let(:priority, OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol)
+          FAST = T.let(:fast, OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol)
+          ULTRAFAST = T.let(:ultrafast, OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol)
 
-          sig do
-            override.returns(
-              T::Array[
-                OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol
-              ]
-            )
-          end
+          sig { override.returns(T::Array[OpenAI::Responses::ResponsesClientEvent::ServiceTier::TaggedSymbol]) }
           def self.values
           end
         end
 
         class StreamOptions < OpenAI::Internal::Type::BaseModel
-          OrHash =
-            T.type_alias do
-              T.any(
-                OpenAI::Responses::ResponsesClientEvent::StreamOptions,
-                OpenAI::Internal::AnyHash
-              )
-            end
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponsesClientEvent::StreamOptions,
+              OpenAI::Internal::AnyHash
+            )
+          end
 
           # When true, stream obfuscation will be enabled. Stream obfuscation adds random
           # characters to an `obfuscation` field on streaming delta events to normalize
@@ -1657,22 +1402,33 @@ module OpenAI
 
           # Options for streaming responses. Only set this when you set `stream: true`.
           sig do
-            params(include_obfuscation: T::Boolean).returns(T.attached_class)
+            params(
+
+              include_obfuscation: T::Boolean
+            )
+              .returns(T.attached_class)
           end
           def self.new(
+
             # 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
           )
           end
 
-          sig { override.returns({ include_obfuscation: T::Boolean }) }
+          sig do
+            override.returns(
+              {include_obfuscation: T::Boolean}
+            )
+          end
           def to_hash
           end
+
         end
 
         # How the model should select which tool (or tools) to use when generating a
@@ -1681,55 +1437,61 @@ module OpenAI
         module ToolChoice
           extend OpenAI::Internal::Type::Union
 
-          Variants =
-            T.type_alias do
+          Variants = T.type_alias {
+            T.any(
+              OpenAI::Responses::ToolChoiceOptions::TaggedSymbol,
+              OpenAI::Responses::ToolChoiceAllowed,
+              OpenAI::Responses::ToolChoiceTypes,
+              OpenAI::Responses::ToolChoiceFunction,
+              OpenAI::Responses::ToolChoiceMcp,
+              OpenAI::Responses::ToolChoiceCustom,
+              OpenAI::Responses::ResponsesClientEvent::ToolChoice::SpecificProgrammaticToolCallingParam,
+              OpenAI::Responses::ToolChoiceApplyPatch,
+              OpenAI::Responses::ToolChoiceShell
+            )
+          }
+
+          class SpecificProgrammaticToolCallingParam < OpenAI::Internal::Type::BaseModel
+            OrHash = T.type_alias do
               T.any(
-                OpenAI::Responses::ToolChoiceOptions::TaggedSymbol,
-                OpenAI::Responses::ToolChoiceAllowed,
-                OpenAI::Responses::ToolChoiceTypes,
-                OpenAI::Responses::ToolChoiceFunction,
-                OpenAI::Responses::ToolChoiceMcp,
-                OpenAI::Responses::ToolChoiceCustom,
                 OpenAI::Responses::ResponsesClientEvent::ToolChoice::SpecificProgrammaticToolCallingParam,
-                OpenAI::Responses::ToolChoiceApplyPatch,
-                OpenAI::Responses::ToolChoiceShell
+                OpenAI::Internal::AnyHash
               )
             end
 
-          class SpecificProgrammaticToolCallingParam < OpenAI::Internal::Type::BaseModel
-            OrHash =
-              T.type_alias do
-                T.any(
-                  OpenAI::Responses::ResponsesClientEvent::ToolChoice::SpecificProgrammaticToolCallingParam,
-                  OpenAI::Internal::AnyHash
-                )
-              end
-
             # The tool to call. Always `programmatic_tool_calling`.
             sig { returns(Symbol) }
             attr_accessor :type
 
-            sig { params(type: Symbol).returns(T.attached_class) }
+            sig do
+              params(
+
+                type: Symbol
+              )
+                .returns(T.attached_class)
+            end
             def self.new(
+
               # The tool to call. Always `programmatic_tool_calling`.
+
               type: :programmatic_tool_calling
             )
             end
 
-            sig { override.returns({ type: Symbol }) }
+            sig do
+              override.returns(
+                {type: Symbol}
+              )
+            end
             def to_hash
             end
-          end
 
-          sig do
-            override.returns(
-              T::Array[
-                OpenAI::Responses::ResponsesClientEvent::ToolChoice::Variants
-              ]
-            )
           end
+
+          sig { override.returns(T::Array[OpenAI::Responses::ResponsesClientEvent::ToolChoice::Variants]) }
           def self.variants
           end
+
         end
 
         # The truncation strategy to use for the model response.
@@ -1742,34 +1504,20 @@ module OpenAI
         module Truncation
           extend OpenAI::Internal::Type::Enum
 
-          TaggedSymbol =
-            T.type_alias do
-              T.all(Symbol, OpenAI::Responses::ResponsesClientEvent::Truncation)
-            end
+          TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Responses::ResponsesClientEvent::Truncation) }
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
-          AUTO =
-            T.let(
-              :auto,
-              OpenAI::Responses::ResponsesClientEvent::Truncation::TaggedSymbol
-            )
-          DISABLED =
-            T.let(
-              :disabled,
-              OpenAI::Responses::ResponsesClientEvent::Truncation::TaggedSymbol
-            )
+          AUTO = T.let(:auto, OpenAI::Responses::ResponsesClientEvent::Truncation::TaggedSymbol)
+          DISABLED = T.let(:disabled, OpenAI::Responses::ResponsesClientEvent::Truncation::TaggedSymbol)
 
-          sig do
-            override.returns(
-              T::Array[
-                OpenAI::Responses::ResponsesClientEvent::Truncation::TaggedSymbol
-              ]
-            )
-          end
+          sig { override.returns(T::Array[OpenAI::Responses::ResponsesClientEvent::Truncation::TaggedSymbol]) }
           def self.values
           end
         end
+
       end
+
     end
+
   end
 end