openai 0.84.0 → 0.85.0

data/lib/openai/models/responses/response_steer_input.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Responses
+      # Input to queue for a continuation of the response. Uses the same string or
+      # input-item shape as `response.create.input`, with a non-empty array when
+      # supplying input items.
+      #
+      # Steering accepts only messages with the `user` role. Each message may contain
+      # only `type`, `role`, and `content`, with `content` as a string or an array of
+      # `input_text`, `input_image`, and `input_file` parts. The optional `type` must be
+      # `message`. Other roles, tool outputs, and item types are not supported for
+      # steering.
+      module ResponseSteerInput
+        extend OpenAI::Internal::Type::Union
+
+        # A text input, equivalent to a message with the `user` role.
+        variant String
+
+        # A non-empty list of message inputs to queue for the response.
+        variant -> { OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemListArray }
+
+        # The output of a function tool call.
+        module ResponseSteerInputItemList
+          extend OpenAI::Internal::Type::Union
+
+          discriminator :type
+
+          variant :message, -> { OpenAI::Responses::ResponseSteerInput::ResponseSteerInputItemList::Message }
+
+          # The output of a function tool call.
+          variant(
+            :function_call_output,
+            -> { OpenAI::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput }
+          )
+
+          class Message < OpenAI::Internal::Type::BaseModel
+            # @!attribute content
+            #   The message content, as an array of content parts.
+            #
+            #   @return [Array<OpenAI::Models::Responses::ResponseInputTextContent, OpenAI::Models::Responses::ResponseInputImageContent, OpenAI::Models::Responses::ResponseInputFileContent>, String]
+            required(
+              :content,
+              union: -> { OpenAI::Responses::ResponseSteerInput::ResponseSteerInputItemList::Message::Content }
+            )
+
+            # @!attribute role
+            #   The message role. Always `user`.
+            #
+            #   @return [Symbol, :user]
+            required :role, const: :user
+
+            # @!attribute type
+            #   The item type. Always `message`.
+            #
+            #   @return [Symbol, :message]
+            required :type, const: :message
+
+            # @!attribute id
+            #   The unique ID of this message item.
+            #
+            #   @return [String, nil]
+            optional :id, String, nil?: true
+
+            # @!attribute status
+            #   The status of the message item.
+            #
+            #   @return [String, nil]
+            optional :status, String, nil?: true
+
+            # @!method initialize(content:, id: nil, status: nil, role: :user, type: :message)
+            #   @param content [Array<OpenAI::Models::Responses::ResponseInputTextContent, OpenAI::Models::Responses::ResponseInputImageContent, OpenAI::Models::Responses::ResponseInputFileContent>, String] The message content, as an array of content parts.
+            #
+            #   @param id [String, nil] The unique ID of this message item.
+            #
+            #   @param status [String, nil] The status of the message item.
+            #
+            #   @param role [Symbol, :user] The message role. Always `user`.
+            #
+            #   @param type [Symbol, :message] The item type. Always `message`.
+
+            # The message content, as an array of content parts.
+            #
+            # @see OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::Message#content
+            module Content
+              extend OpenAI::Internal::Type::Union
+
+              variant(
+                -> {
+                  OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::Message::Content::ResponseSteerInputContentArray
+                }
+              )
+
+              # The message content, as a single string.
+              variant String
+
+              # @!method self.variants
+              #   @return [Array(Array<OpenAI::Models::Responses::ResponseInputTextContent, OpenAI::Models::Responses::ResponseInputImageContent, OpenAI::Models::Responses::ResponseInputFileContent>, String)]
+
+              # @type [OpenAI::Internal::Type::Converter]
+              ResponseSteerInputContentArray = OpenAI::Internal::Type::ArrayOf[
+                union: -> { OpenAI::Responses::ResponseSteerInputContent }
+              ]
+            end
+          end
+
+          class FunctionCallOutput < OpenAI::Internal::Type::BaseModel
+            # @!attribute output
+            #   Text, image, or file output of the function tool call.
+            #
+            #   @return [String, Array<OpenAI::Models::Responses::ResponseInputTextContent, OpenAI::Models::Responses::ResponseInputImageContent, OpenAI::Models::Responses::ResponseInputFileContent>]
+            required(
+              :output,
+              union: -> {
+                OpenAI::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Output
+              }
+            )
+
+            # @!attribute type
+            #   The type of the function tool call output. Always `function_call_output`.
+            #
+            #   @return [Symbol, :function_call_output]
+            required :type, const: :function_call_output
+
+            # @!attribute id
+            #   The unique ID of the function tool call output. Populated when this item is
+            #   returned via API.
+            #
+            #   @return [String, nil]
+            optional :id, String, nil?: true
+
+            # @!attribute call_id
+            #   The unique ID of the function tool call generated by the model.
+            #
+            #   @return [String, nil]
+            optional :call_id, String, nil?: true
+
+            # @!attribute caller_
+            #   The execution context that produced this tool call.
+            #
+            #   @return [OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Caller::Direct, OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Caller::Program, nil]
+            optional(
+              :caller_,
+              union: -> {
+                OpenAI::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Caller
+              },
+              api_name: :caller,
+              nil?: true
+            )
+
+            # @!attribute name
+            #   The name of the tool that produced the output.
+            #
+            #   @return [String, nil]
+            optional :name, String, nil?: true
+
+            # @!attribute namespace
+            #   The namespace of the tool that produced the output.
+            #
+            #   @return [String, nil]
+            optional :namespace, String, nil?: true
+
+            # @!attribute status
+            #   The status of the item. One of `in_progress`, `completed`, or `incomplete`.
+            #   Populated when items are returned via API.
+            #
+            #   @return [Symbol, OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Status, nil]
+            optional(
+              :status,
+              enum: -> {
+                OpenAI::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Status
+              },
+              nil?: true
+            )
+
+            # @!method initialize(output:, id: nil, call_id: nil, caller_: nil, name: nil, namespace: nil, status: nil, type: :function_call_output)
+            #   Some parameter documentations has been truncated, see
+            #   {OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput}
+            #   for more details.
+            #
+            #   The output of a function tool call.
+            #
+            #   @param output [String, Array<OpenAI::Models::Responses::ResponseInputTextContent, OpenAI::Models::Responses::ResponseInputImageContent, OpenAI::Models::Responses::ResponseInputFileContent>] Text, image, or file output of the function tool call.
+            #
+            #   @param id [String, nil] The unique ID of the function tool call output. Populated when this item is retu
+            #
+            #   @param call_id [String, nil] The unique ID of the function tool call generated by the model.
+            #
+            #   @param caller_ [OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Caller::Direct, OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Caller::Program, nil] The execution context that produced this tool call.
+            #
+            #   @param name [String, nil] The name of the tool that produced the output.
+            #
+            #   @param namespace [String, nil] The namespace of the tool that produced the output.
+            #
+            #   @param status [Symbol, OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Status, nil] The status of the item. One of `in_progress`, `completed`, or `incomplete`. Popu
+            #
+            #   @param type [Symbol, :function_call_output] The type of the function tool call output. Always `function_call_output`.
+
+            # Text, image, or file output of the function tool call.
+            #
+            # @see OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput#output
+            module Output
+              extend OpenAI::Internal::Type::Union
+
+              # A JSON string of the output of the function tool call.
+              variant String
+
+              # An array of content outputs (text, image, file) for the function tool call.
+              variant -> { OpenAI::Responses::ResponseFunctionCallOutputItemList }
+
+              # @!method self.variants
+              #   @return [Array(String, Array<OpenAI::Models::Responses::ResponseInputTextContent, OpenAI::Models::Responses::ResponseInputImageContent, OpenAI::Models::Responses::ResponseInputFileContent>)]
+            end
+
+            # The execution context that produced this tool call.
+            #
+            # @see OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput#caller_
+            module Caller
+              extend OpenAI::Internal::Type::Union
+
+              discriminator :type
+
+              variant(
+                :direct,
+                -> {
+                  OpenAI::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Caller::Direct
+                }
+              )
+
+              variant(
+                :program,
+                -> {
+                  OpenAI::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Caller::Program
+                }
+              )
+
+              class Direct < OpenAI::Internal::Type::BaseModel
+                # @!attribute type
+                #   The caller type. Always `direct`.
+                #
+                #   @return [Symbol, :direct]
+                required :type, const: :direct
+
+                # @!method initialize(type: :direct)
+                #   @param type [Symbol, :direct] The caller type. Always `direct`.
+              end
+
+              class Program < OpenAI::Internal::Type::BaseModel
+                # @!attribute caller_id
+                #   The call ID of the program item that produced this tool call.
+                #
+                #   @return [String]
+                required :caller_id, String
+
+                # @!attribute type
+                #   The caller type. Always `program`.
+                #
+                #   @return [Symbol, :program]
+                required :type, const: :program
+
+                # @!method initialize(caller_id:, type: :program)
+                #   @param caller_id [String] The call ID of the program item that produced this tool call.
+                #
+                #   @param type [Symbol, :program] The caller type. Always `program`.
+              end
+
+              # @!method self.variants
+              #   @return [Array(OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Caller::Direct, OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput::Caller::Program)]
+            end
+
+            # The status of the item. One of `in_progress`, `completed`, or `incomplete`.
+            # Populated when items are returned via API.
+            #
+            # @see OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput#status
+            module Status
+              extend OpenAI::Internal::Type::Enum
+
+              IN_PROGRESS = :in_progress
+              COMPLETED = :completed
+              INCOMPLETE = :incomplete
+
+              # @!method self.values
+              #   @return [Array<Symbol>]
+            end
+          end
+
+          # @!method self.variants
+          #   @return [Array(OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::Message, OpenAI::Models::Responses::ResponseSteerInput::ResponseSteerInputItemList::FunctionCallOutput)]
+        end
+
+        # @!method self.variants
+        #   @return [Array(String, Array<Hash{Symbol=>Object}>)]
+
+        # @type [OpenAI::Internal::Type::Converter]
+        ResponseSteerInputItemListArray = OpenAI::Internal::Type::ArrayOf[
+          union: -> {
+            OpenAI::Responses::ResponseSteerInput::ResponseSteerInputItemList
+          }
+        ]
+      end
+    end
+  end
+end

data/lib/openai/models/responses/response_steer_input_content.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Responses
+      # A piece of message content, such as text, an image, or a file.
+      module ResponseSteerInputContent
+        extend OpenAI::Internal::Type::Union
+
+        discriminator :type
+
+        # A text input to the model.
+        variant :input_text, -> { OpenAI::Responses::ResponseInputTextContent }
+
+        # An image input to the model. Learn about [image inputs](https://platform.openai.com/docs/guides/vision)
+        variant :input_image, -> { OpenAI::Responses::ResponseInputImageContent }
+
+        # A file input to the model.
+        variant :input_file, -> { OpenAI::Responses::ResponseInputFileContent }
+
+        # @!method self.variants
+        #   @return [Array(OpenAI::Models::Responses::ResponseInputTextContent, OpenAI::Models::Responses::ResponseInputImageContent, OpenAI::Models::Responses::ResponseInputFileContent)]
+      end
+    end
+  end
+end

data/lib/openai/models/responses/response_steer_pending_event.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Responses
+      class ResponseSteerPendingEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute reason
+        #   An extensible enum describing why accepted steering input is still queued.
+        #   Clients should handle unknown values because additional reasons may be
+        #   introduced. Known values include:
+        #
+        #   - `waiting_for_required_input`: The response is waiting for the tool results or
+        #     approval decisions identified by `required_input`.
+        #
+        #   @return [Symbol, :waiting_for_required_input, String]
+        required :reason, union: -> { OpenAI::Responses::ResponseSteerPendingReason }
+
+        # @!attribute required_input
+        #   Input stubs identifying outstanding client-owned tool results or approval
+        #   decisions. Each stub contains identifying fields only; the client supplies the
+        #   result before including it in `response.create`.
+        #
+        #   @return [Array<OpenAI::Models::Responses::ResponseSteerRequiredInput::FunctionCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::CustomToolCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::ComputerCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::ShellCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::ApplyPatchCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::ToolSearchOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::McpApprovalResponse>]
+        required(
+          :required_input,
+          -> { OpenAI::Internal::Type::ArrayOf[union: OpenAI::Responses::ResponseSteerRequiredInput] }
+        )
+
+        # @!attribute sequence_number
+        #   The sequence number for this event.
+        #
+        #   @return [Integer]
+        required :sequence_number, Integer
+
+        # @!attribute steer
+        #   The steering submission that remains queued.
+        #
+        #   @return [OpenAI::Models::Responses::ResponseSteerPendingEvent::Steer]
+        required :steer, -> { OpenAI::Responses::ResponseSteerPendingEvent::Steer }
+
+        # @!attribute type
+        #   The event discriminator. Always `response.steer.pending`.
+        #
+        #   @return [Symbol, :"response.steer.pending"]
+        required :type, const: :"response.steer.pending"
+
+        # @!attribute stream_id
+        #   The WebSocket lane that emitted this event. This field is present when the
+        #   target response's `response.create` event supplied a `stream_id`.
+        #
+        #   @return [String, nil]
+        optional :stream_id, String
+
+        # @!method initialize(reason:, required_input:, sequence_number:, steer:, stream_id: nil, type: :"response.steer.pending")
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Responses::ResponseSteerPendingEvent} for more details.
+        #
+        #   Emitted when accepted steering input remains queued after the target response
+        #   completes. The server still owns the input. Do not resend it. The successor's
+        #   `response.created` event is the commit point.
+        #
+        #   When `reason` is `waiting_for_required_input`, this event follows
+        #   `response.completed` while the response waits for the tool results or approval
+        #   decisions identified by `required_input`. Copy those stubs, fill their result
+        #   fields using the ordinary `response.create` input schemas, and submit one
+        #   continuation per parent with the same `previous_response_id` and WebSocket lane.
+        #   Use saved results without rerunning tools. The queued steering input is
+        #   prepended in submission order to the continuation's input. That explicit request
+        #   retains its own settings.
+        #
+        #   This notification is emitted at most once per steering submission. Multiple
+        #   submissions for the same parent can report the same required inputs; they do not
+        #   each require a separate continuation.
+        #
+        #   @param reason [Symbol, :waiting_for_required_input, String] An extensible enum describing why accepted steering input is still queued.
+        #
+        #   @param required_input [Array<OpenAI::Models::Responses::ResponseSteerRequiredInput::FunctionCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::CustomToolCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::ComputerCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::ShellCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::ApplyPatchCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::ToolSearchOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::McpApprovalResponse>] Input stubs identifying outstanding client-owned tool results or
+        #
+        #   @param sequence_number [Integer] The sequence number for this event.
+        #
+        #   @param steer [OpenAI::Models::Responses::ResponseSteerPendingEvent::Steer] The steering submission that remains queued.
+        #
+        #   @param stream_id [String] The WebSocket lane that emitted this event. This field is present when
+        #
+        #   @param type [Symbol, :"response.steer.pending"] The event discriminator. Always `response.steer.pending`.
+
+        # @see OpenAI::Models::Responses::ResponseSteerPendingEvent#steer
+        class Steer < OpenAI::Internal::Type::BaseModel
+          # @!attribute id
+          #   The ID assigned to the steering submission.
+          #
+          #   @return [String]
+          required :id, String
+
+          # @!attribute previous_response_id
+          #   The ID of the response being steered.
+          #
+          #   @return [String]
+          required :previous_response_id, String
+
+          # @!method initialize(id:, previous_response_id:)
+          #   The steering submission that remains queued.
+          #
+          #   @param id [String] The ID assigned to the steering submission.
+          #
+          #   @param previous_response_id [String] The ID of the response being steered.
+        end
+      end
+    end
+  end
+end

data/lib/openai/models/responses/response_steer_pending_reason.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Responses
+      # An extensible enum describing why accepted steering input is still queued.
+      # Clients should handle unknown values because additional reasons may be
+      # introduced. Known values include:
+      #
+      # - `waiting_for_required_input`: The response is waiting for the tool results or
+      #   approval decisions identified by `required_input`.
+      module ResponseSteerPendingReason
+        extend OpenAI::Internal::Type::Union
+
+        variant const: :waiting_for_required_input
+
+        variant String
+
+        # @!method self.variants
+        #   @return [Array(Symbol, :waiting_for_required_input, String)]
+      end
+    end
+  end
+end

data/lib/openai/models/responses/response_steer_required_input.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Responses
+      # An input stub identifying an outstanding client-owned tool result or approval
+      # decision. Copy the stub and fill the result fields using the corresponding
+      # `response.create` input schema. Use saved results without rerunning the tool.
+      # The server does not supply results, approval decisions, or safety
+      # acknowledgements in these stubs.
+      module ResponseSteerRequiredInput
+        extend OpenAI::Internal::Type::Union
+
+        discriminator :type
+
+        # Supply `output` using the function tool call output input schema.
+        variant :function_call_output, -> { OpenAI::Responses::ResponseSteerRequiredInput::FunctionCallOutput }
+
+        # Supply `output` using the custom tool call output input schema. The
+        # original custom tool call supplies the tool's name.
+        variant(
+          :custom_tool_call_output,
+          -> { OpenAI::Responses::ResponseSteerRequiredInput::CustomToolCallOutput }
+        )
+
+        # Supply `output` using the computer tool call output input schema,
+        # including any required `acknowledged_safety_checks`.
+        variant :computer_call_output, -> { OpenAI::Responses::ResponseSteerRequiredInput::ComputerCallOutput }
+
+        # Supply `output` using the shell tool call output input schema. Each
+        # output entry includes `stdout`, `stderr`, and `outcome`.
+        variant :shell_call_output, -> { OpenAI::Responses::ResponseSteerRequiredInput::ShellCallOutput }
+
+        # Supply `status` and optional `output` using the apply patch tool call
+        # output input schema.
+        variant(
+          :apply_patch_call_output,
+          -> { OpenAI::Responses::ResponseSteerRequiredInput::ApplyPatchCallOutput }
+        )
+
+        # Supply `tools` using the tool search output input schema, retaining
+        # `execution: "client"`.
+        variant :tool_search_output, -> { OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput }
+
+        # Supply `approve` using the MCP approval response input schema. An
+        # optional `reason` can be supplied when denying the request. The original
+        # approval request identifies the tool and server.
+        variant :mcp_approval_response, -> { OpenAI::Responses::ResponseSteerRequiredInput::McpApprovalResponse }
+
+        class FunctionCallOutput < OpenAI::Internal::Type::BaseModel
+          # @!attribute call_id
+          #
+          #   @return [String]
+          required :call_id, String
+
+          # @!attribute name
+          #
+          #   @return [String]
+          required :name, String
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :function_call_output]
+          required :type, const: :function_call_output
+
+          # @!method initialize(call_id:, name:, type: :function_call_output)
+          #   Supply `output` using the function tool call output input schema.
+          #
+          #   @param call_id [String]
+          #   @param name [String]
+          #   @param type [Symbol, :function_call_output]
+        end
+
+        class CustomToolCallOutput < OpenAI::Internal::Type::BaseModel
+          # @!attribute call_id
+          #
+          #   @return [String]
+          required :call_id, String
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :custom_tool_call_output]
+          required :type, const: :custom_tool_call_output
+
+          # @!method initialize(call_id:, type: :custom_tool_call_output)
+          #   Supply `output` using the custom tool call output input schema. The original
+          #   custom tool call supplies the tool's name.
+          #
+          #   @param call_id [String]
+          #   @param type [Symbol, :custom_tool_call_output]
+        end
+
+        class ComputerCallOutput < OpenAI::Internal::Type::BaseModel
+          # @!attribute call_id
+          #
+          #   @return [String]
+          required :call_id, String
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :computer_call_output]
+          required :type, const: :computer_call_output
+
+          # @!method initialize(call_id:, type: :computer_call_output)
+          #   Supply `output` using the computer tool call output input schema, including any
+          #   required `acknowledged_safety_checks`.
+          #
+          #   @param call_id [String]
+          #   @param type [Symbol, :computer_call_output]
+        end
+
+        class ShellCallOutput < OpenAI::Internal::Type::BaseModel
+          # @!attribute call_id
+          #
+          #   @return [String]
+          required :call_id, String
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :shell_call_output]
+          required :type, const: :shell_call_output
+
+          # @!method initialize(call_id:, type: :shell_call_output)
+          #   Supply `output` using the shell tool call output input schema. Each output entry
+          #   includes `stdout`, `stderr`, and `outcome`.
+          #
+          #   @param call_id [String]
+          #   @param type [Symbol, :shell_call_output]
+        end
+
+        class ApplyPatchCallOutput < OpenAI::Internal::Type::BaseModel
+          # @!attribute call_id
+          #
+          #   @return [String]
+          required :call_id, String
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :apply_patch_call_output]
+          required :type, const: :apply_patch_call_output
+
+          # @!method initialize(call_id:, type: :apply_patch_call_output)
+          #   Supply `status` and optional `output` using the apply patch tool call output
+          #   input schema.
+          #
+          #   @param call_id [String]
+          #   @param type [Symbol, :apply_patch_call_output]
+        end
+
+        class ToolSearchOutput < OpenAI::Internal::Type::BaseModel
+          # @!attribute call_id
+          #
+          #   @return [String]
+          required :call_id, String
+
+          # @!attribute execution
+          #
+          #   @return [Symbol, OpenAI::Models::Responses::ResponseSteerRequiredInput::ToolSearchOutput::Execution]
+          required(
+            :execution,
+            enum: -> { OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput::Execution }
+          )
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :tool_search_output]
+          required :type, const: :tool_search_output
+
+          # @!method initialize(call_id:, execution:, type: :tool_search_output)
+          #   Supply `tools` using the tool search output input schema, retaining
+          #   `execution: "client"`.
+          #
+          #   @param call_id [String]
+          #   @param execution [Symbol, OpenAI::Models::Responses::ResponseSteerRequiredInput::ToolSearchOutput::Execution]
+          #   @param type [Symbol, :tool_search_output]
+
+          # @see OpenAI::Models::Responses::ResponseSteerRequiredInput::ToolSearchOutput#execution
+          module Execution
+            extend OpenAI::Internal::Type::Enum
+
+            CLIENT = :client
+
+            # @!method self.values
+            #   @return [Array<Symbol>]
+          end
+        end
+
+        class McpApprovalResponse < OpenAI::Internal::Type::BaseModel
+          # @!attribute approval_request_id
+          #
+          #   @return [String]
+          required :approval_request_id, String
+
+          # @!attribute type
+          #
+          #   @return [Symbol, :mcp_approval_response]
+          required :type, const: :mcp_approval_response
+
+          # @!method initialize(approval_request_id:, type: :mcp_approval_response)
+          #   Supply `approve` using the MCP approval response input schema. An optional
+          #   `reason` can be supplied when denying the request. The original approval request
+          #   identifies the tool and server.
+          #
+          #   @param approval_request_id [String]
+          #   @param type [Symbol, :mcp_approval_response]
+        end
+
+        # @!method self.variants
+        #   @return [Array(OpenAI::Models::Responses::ResponseSteerRequiredInput::FunctionCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::CustomToolCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::ComputerCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::ShellCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::ApplyPatchCallOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::ToolSearchOutput, OpenAI::Models::Responses::ResponseSteerRequiredInput::McpApprovalResponse)]
+      end
+    end
+  end
+end