openai 0.83.0 → 0.85.0

data/rbi/openai/models/responses/response_steer_pending_event.rbi

@@ -0,0 +1,220 @@
+# typed: strong
+
+module OpenAI
+  module Models
+
+    module Responses
+
+      class ResponseSteerPendingEvent < OpenAI::Internal::Type::BaseModel
+
+        OrHash = T.type_alias do
+          T.any(
+            OpenAI::Responses::ResponseSteerPendingEvent,
+            OpenAI::Internal::AnyHash
+          )
+        end
+
+        # 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`.
+        sig { returns(OpenAI::Responses::ResponseSteerPendingReason::Variants) }
+        attr_accessor :reason
+
+        # 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`.
+        sig {
+          returns(
+            T::Array[
+              T.any(
+                OpenAI::Responses::ResponseSteerRequiredInput::FunctionCallOutput,
+                OpenAI::Responses::ResponseSteerRequiredInput::CustomToolCallOutput,
+                OpenAI::Responses::ResponseSteerRequiredInput::ComputerCallOutput,
+                OpenAI::Responses::ResponseSteerRequiredInput::ShellCallOutput,
+                OpenAI::Responses::ResponseSteerRequiredInput::ApplyPatchCallOutput,
+                OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput,
+                OpenAI::Responses::ResponseSteerRequiredInput::McpApprovalResponse
+              )
+            ]
+          )
+        }
+        attr_accessor :required_input
+
+        # The sequence number for this event.
+        sig { returns(Integer) }
+        attr_accessor :sequence_number
+
+        # The steering submission that remains queued.
+        sig { returns(OpenAI::Responses::ResponseSteerPendingEvent::Steer) }
+        attr_reader :steer
+
+        sig { params(steer: OpenAI::Responses::ResponseSteerPendingEvent::Steer::OrHash).void }
+        attr_writer :steer
+
+        # The event discriminator. Always `response.steer.pending`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The WebSocket lane that emitted this event. This field is present when the
+        # target response's `response.create` event supplied a `stream_id`.
+        sig { returns(T.nilable(String)) }
+        attr_reader :stream_id
+
+        sig { params(stream_id: String).void }
+        attr_writer :stream_id
+
+        # 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.
+        sig do
+          params(
+
+            reason: T.any(Symbol, String),
+
+            required_input: T::Array[
+              T.any(
+                OpenAI::Responses::ResponseSteerRequiredInput::FunctionCallOutput::OrHash,
+                OpenAI::Responses::ResponseSteerRequiredInput::CustomToolCallOutput::OrHash,
+                OpenAI::Responses::ResponseSteerRequiredInput::ComputerCallOutput::OrHash,
+                OpenAI::Responses::ResponseSteerRequiredInput::ShellCallOutput::OrHash,
+                OpenAI::Responses::ResponseSteerRequiredInput::ApplyPatchCallOutput::OrHash,
+                OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput::OrHash,
+                OpenAI::Responses::ResponseSteerRequiredInput::McpApprovalResponse::OrHash
+              )
+            ],
+
+            sequence_number: Integer,
+
+            steer: OpenAI::Responses::ResponseSteerPendingEvent::Steer::OrHash,
+
+            stream_id: String,
+
+            type: Symbol
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+
+          # 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`.
+          reason:,
+
+          # 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`.
+          required_input:,
+
+          # The sequence number for this event.
+          sequence_number:,
+
+          # The steering submission that remains queued.
+          steer:,
+
+          # The WebSocket lane that emitted this event. This field is present when the
+          # target response's `response.create` event supplied a `stream_id`.
+          stream_id: nil,
+
+          # The event discriminator. Always `response.steer.pending`.
+
+          type: :"response.steer.pending"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              reason: OpenAI::Responses::ResponseSteerPendingReason::Variants,
+              required_input: T::Array[
+                T.any(
+                  OpenAI::Responses::ResponseSteerRequiredInput::FunctionCallOutput,
+                  OpenAI::Responses::ResponseSteerRequiredInput::CustomToolCallOutput,
+                  OpenAI::Responses::ResponseSteerRequiredInput::ComputerCallOutput,
+                  OpenAI::Responses::ResponseSteerRequiredInput::ShellCallOutput,
+                  OpenAI::Responses::ResponseSteerRequiredInput::ApplyPatchCallOutput,
+                  OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput,
+                  OpenAI::Responses::ResponseSteerRequiredInput::McpApprovalResponse
+                )
+              ],
+              sequence_number: Integer,
+              steer: OpenAI::Responses::ResponseSteerPendingEvent::Steer,
+              type: Symbol,
+              stream_id: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Steer < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseSteerPendingEvent::Steer,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          # The ID assigned to the steering submission.
+          sig { returns(String) }
+          attr_accessor :id
+
+          # The ID of the response being steered.
+          sig { returns(String) }
+          attr_accessor :previous_response_id
+
+          # The steering submission that remains queued.
+          sig do
+            params(
+
+              id: String,
+
+              previous_response_id: String
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            # The ID assigned to the steering submission.
+            id:,
+
+            # The ID of the response being steered.
+
+            previous_response_id:
+          )
+          end
+
+          sig do
+            override.returns(
+              {id: String, previous_response_id: String}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/responses/response_steer_pending_reason.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+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
+
+        Variants = T.type_alias do
+          T.any(
+            Symbol,
+            String
+          )
+        end
+
+        sig { override.returns(T::Array[OpenAI::Responses::ResponseSteerPendingReason::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/responses/response_steer_required_input.rbi

@@ -0,0 +1,377 @@
+# typed: strong
+
+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
+
+        Variants = T.type_alias do
+          T.any(
+            OpenAI::Responses::ResponseSteerRequiredInput::FunctionCallOutput,
+            OpenAI::Responses::ResponseSteerRequiredInput::CustomToolCallOutput,
+            OpenAI::Responses::ResponseSteerRequiredInput::ComputerCallOutput,
+            OpenAI::Responses::ResponseSteerRequiredInput::ShellCallOutput,
+            OpenAI::Responses::ResponseSteerRequiredInput::ApplyPatchCallOutput,
+            OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput,
+            OpenAI::Responses::ResponseSteerRequiredInput::McpApprovalResponse
+          )
+        end
+
+        class FunctionCallOutput < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseSteerRequiredInput::FunctionCallOutput,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :call_id
+
+          sig { returns(String) }
+          attr_accessor :name
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Supply `output` using the function tool call output input schema.
+          sig do
+            params(
+
+              call_id: String,
+
+              name: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            call_id:,
+
+            name:,
+
+            type: :function_call_output
+          )
+          end
+
+          sig do
+            override.returns(
+              {call_id: String, name: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class CustomToolCallOutput < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseSteerRequiredInput::CustomToolCallOutput,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :call_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Supply `output` using the custom tool call output input schema. The original
+          # custom tool call supplies the tool's name.
+          sig do
+            params(
+
+              call_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            call_id:,
+
+            type: :custom_tool_call_output
+          )
+          end
+
+          sig do
+            override.returns(
+              {call_id: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class ComputerCallOutput < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseSteerRequiredInput::ComputerCallOutput,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :call_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Supply `output` using the computer tool call output input schema, including any
+          # required `acknowledged_safety_checks`.
+          sig do
+            params(
+
+              call_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            call_id:,
+
+            type: :computer_call_output
+          )
+          end
+
+          sig do
+            override.returns(
+              {call_id: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class ShellCallOutput < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseSteerRequiredInput::ShellCallOutput,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :call_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Supply `output` using the shell tool call output input schema. Each output entry
+          # includes `stdout`, `stderr`, and `outcome`.
+          sig do
+            params(
+
+              call_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            call_id:,
+
+            type: :shell_call_output
+          )
+          end
+
+          sig do
+            override.returns(
+              {call_id: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class ApplyPatchCallOutput < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseSteerRequiredInput::ApplyPatchCallOutput,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :call_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Supply `status` and optional `output` using the apply patch tool call output
+          # input schema.
+          sig do
+            params(
+
+              call_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            call_id:,
+
+            type: :apply_patch_call_output
+          )
+          end
+
+          sig do
+            override.returns(
+              {call_id: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        class ToolSearchOutput < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :call_id
+
+          sig { returns(OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput::Execution::TaggedSymbol) }
+          attr_accessor :execution
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Supply `tools` using the tool search output input schema, retaining
+          # `execution: "client"`.
+          sig do
+            params(
+
+              call_id: String,
+
+              execution: OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput::Execution::OrSymbol,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            call_id:,
+
+            execution:,
+
+            type: :tool_search_output
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                call_id: String,
+                execution: OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput::Execution::TaggedSymbol,
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Execution
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol = T.type_alias {
+              T.all(Symbol, OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput::Execution)
+            }
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            CLIENT = T.let(
+              :client,
+              OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput::Execution::TaggedSymbol
+            )
+
+            sig {
+              override.returns(
+                T::Array[OpenAI::Responses::ResponseSteerRequiredInput::ToolSearchOutput::Execution::TaggedSymbol]
+              )
+            }
+            def self.values
+            end
+          end
+        end
+
+        class McpApprovalResponse < OpenAI::Internal::Type::BaseModel
+          OrHash = T.type_alias do
+            T.any(
+              OpenAI::Responses::ResponseSteerRequiredInput::McpApprovalResponse,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+          sig { returns(String) }
+          attr_accessor :approval_request_id
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # 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.
+          sig do
+            params(
+
+              approval_request_id: String,
+
+              type: Symbol
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(
+
+            approval_request_id:,
+
+            type: :mcp_approval_response
+          )
+          end
+
+          sig do
+            override.returns(
+              {approval_request_id: String, type: Symbol}
+            )
+          end
+          def to_hash
+          end
+
+        end
+
+        sig { override.returns(T::Array[OpenAI::Responses::ResponseSteerRequiredInput::Variants]) }
+        def self.variants
+        end
+
+      end
+
+    end
+
+  end
+end

data/rbi/openai/models/responses/response_usage.rbi

@@ -40,10 +40,6 @@ module OpenAI
         sig { returns(Integer) }
         attr_accessor :total_tokens
 
-        # Compute units for the request. Currently null when available.
-        sig { returns(T.nilable(Integer)) }
-        attr_accessor :compute_units
-
         # Represents token usage details including input tokens, output tokens, a
         # breakdown of output tokens, and the total tokens used.
         sig do
@@ -57,9 +53,7 @@ module OpenAI
 
             output_tokens_details: OpenAI::Responses::ResponseUsage::OutputTokensDetails::OrHash,
 
-            total_tokens: Integer,
-
-            compute_units: T.nilable(Integer)
+            total_tokens: Integer
           )
             .returns(T.attached_class)
         end
@@ -78,11 +72,8 @@ module OpenAI
           output_tokens_details:,
 
           # The total number of tokens used.
-          total_tokens:,
-
-          # Compute units for the request. Currently null when available.
 
-          compute_units: nil
+          total_tokens:
         )
         end
 
@@ -93,8 +84,7 @@ module OpenAI
               input_tokens_details: OpenAI::Responses::ResponseUsage::InputTokensDetails,
               output_tokens: Integer,
               output_tokens_details: OpenAI::Responses::ResponseUsage::OutputTokensDetails,
-              total_tokens: Integer,
-              compute_units: T.nilable(Integer)
+              total_tokens: Integer
             }
           )
         end