openai 0.83.0 → 0.85.0

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Models
+    module Responses
+      class ResponseSteerFailedEvent < OpenAI::Internal::Type::BaseModel
+        # @!attribute error
+        #   Information about why the input could not be committed.
+        #
+        #   @return [OpenAI::Models::Responses::ResponseSteerFailedEvent::Error]
+        required :error, -> { OpenAI::Responses::ResponseSteerFailedEvent::Error }
+
+        # @!attribute sequence_number
+        #   The sequence number for this event.
+        #
+        #   @return [Integer]
+        required :sequence_number, Integer
+
+        # @!attribute steer
+        #   The steering submission that could not be committed.
+        #
+        #   @return [OpenAI::Models::Responses::ResponseSteerFailedEvent::Steer]
+        required :steer, -> { OpenAI::Responses::ResponseSteerFailedEvent::Steer }
+
+        # @!attribute type
+        #   The event discriminator. Always `response.steer.failed`.
+        #
+        #   @return [Symbol, :"response.steer.failed"]
+        required :type, const: :"response.steer.failed"
+
+        # @!attribute stream_id
+        #   The WebSocket lane that emitted this event, when the target response is
+        #   available and its `response.create` event supplied a `stream_id`.
+        #
+        #   @return [String, nil]
+        optional :stream_id, String
+
+        # @!method initialize(error:, sequence_number:, steer:, stream_id: nil, type: :"response.steer.failed")
+        #   Some parameter documentations has been truncated, see
+        #   {OpenAI::Models::Responses::ResponseSteerFailedEvent} for more details.
+        #
+        #   Emitted when steering input is rejected or cannot be committed to a successor
+        #   response. Returns the original, uncommitted input so the client can carry it
+        #   into `response.create` when appropriate. Invalid input must be corrected before
+        #   retrying.
+        #
+        #   Failures after acceptance include the same steering ID. Failures before an ID is
+        #   allocated omit `steer.id`. A lost connection or missing acknowledgement leaves
+        #   the outcome unknown; it is not proof that the input was rejected.
+        #
+        #   @param error [OpenAI::Models::Responses::ResponseSteerFailedEvent::Error] Information about why the input could not be committed.
+        #
+        #   @param sequence_number [Integer] The sequence number for this event.
+        #
+        #   @param steer [OpenAI::Models::Responses::ResponseSteerFailedEvent::Steer] The steering submission that could not be committed.
+        #
+        #   @param stream_id [String] The WebSocket lane that emitted this event, when the target response is
+        #
+        #   @param type [Symbol, :"response.steer.failed"] The event discriminator. Always `response.steer.failed`.
+
+        # @see OpenAI::Models::Responses::ResponseSteerFailedEvent#error
+        class Error < OpenAI::Internal::Type::BaseModel
+          # @!attribute code
+          #   A machine-readable steering error code. Clients should handle unknown values
+          #   because additional codes may be introduced. Known values include:
+          #
+          #   - `response_not_found`: The target response is not available on this connection.
+          #   - `invalid_input`: The event or input failed validation.
+          #   - `steering_not_supported`: The model or response execution mode does not
+          #     support steering.
+          #   - `too_many_pending_steers`: Too much steering input is pending for the
+          #     response.
+          #   - `response_already_completed`: The response completed and is no longer
+          #     accepting steering input.
+          #   - `response_not_active`: The response is no longer accepting steering input.
+          #   - `successor_creation_failed`: The successor response could not be created.
+          #
+          #   @return [Symbol, String, OpenAI::Models::Responses::ResponseSteerErrorCode]
+          required :code, union: -> { OpenAI::Responses::ResponseSteerErrorCode }
+
+          # @!attribute message
+          #   A human-readable description of the error.
+          #
+          #   @return [String]
+          required :message, String
+
+          # @!attribute type
+          #   The error type. Always `invalid_request_error`.
+          #
+          #   @return [Symbol, :invalid_request_error]
+          required :type, const: :invalid_request_error
+
+          # @!method initialize(code:, message:, type: :invalid_request_error)
+          #   Some parameter documentations has been truncated, see
+          #   {OpenAI::Models::Responses::ResponseSteerFailedEvent::Error} for more details.
+          #
+          #   Information about why the input could not be committed.
+          #
+          #   @param code [Symbol, String, OpenAI::Models::Responses::ResponseSteerErrorCode] A machine-readable steering error code. Clients should handle unknown
+          #
+          #   @param message [String] A human-readable description of the error.
+          #
+          #   @param type [Symbol, :invalid_request_error] The error type. Always `invalid_request_error`.
+        end
+
+        # @see OpenAI::Models::Responses::ResponseSteerFailedEvent#steer
+        class Steer < OpenAI::Internal::Type::BaseModel
+          # @!attribute input
+          #   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.
+          #
+          #   @return [String, Array<Hash{Symbol=>Object}>]
+          required :input, union: -> { OpenAI::Responses::ResponseSteerInput }
+
+          # @!attribute previous_response_id
+          #   The ID of the response that was targeted for steering.
+          #
+          #   @return [String]
+          required :previous_response_id, String
+
+          # @!attribute id
+          #   The ID assigned to the steering submission, if one was allocated.
+          #
+          #   @return [String, nil]
+          optional :id, String
+
+          # @!method initialize(input:, previous_response_id:, id: nil)
+          #   Some parameter documentations has been truncated, see
+          #   {OpenAI::Models::Responses::ResponseSteerFailedEvent::Steer} for more details.
+          #
+          #   The steering submission that could not be committed.
+          #
+          #   @param input [String, Array<Hash{Symbol=>Object}>] Input to queue for a continuation of the response. Uses the same string or
+          #
+          #   @param previous_response_id [String] The ID of the response that was targeted for steering.
+          #
+          #   @param id [String] The ID assigned to the steering submission, if one was allocated.
+        end
+      end
+    end
+  end
+end

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