openai 0.50.0 → 0.52.0

data/rbi/openai/models/responses/computer_action.rbi

@@ -0,0 +1,534 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      # A click action.
+      module ComputerAction
+        extend OpenAI::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              OpenAI::Responses::ComputerAction::Click,
+              OpenAI::Responses::ComputerAction::DoubleClick,
+              OpenAI::Responses::ComputerAction::Drag,
+              OpenAI::Responses::ComputerAction::Keypress,
+              OpenAI::Responses::ComputerAction::Move,
+              OpenAI::Responses::ComputerAction::Screenshot,
+              OpenAI::Responses::ComputerAction::Scroll,
+              OpenAI::Responses::ComputerAction::Type,
+              OpenAI::Responses::ComputerAction::Wait
+            )
+          end
+
+        class Click < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ComputerAction::Click,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # Indicates which mouse button was pressed during the click. One of `left`,
+          # `right`, `wheel`, `back`, or `forward`.
+          sig do
+            returns(OpenAI::Responses::ComputerAction::Click::Button::OrSymbol)
+          end
+          attr_accessor :button
+
+          # Specifies the event type. For a click action, this property is always `click`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The x-coordinate where the click occurred.
+          sig { returns(Integer) }
+          attr_accessor :x
+
+          # The y-coordinate where the click occurred.
+          sig { returns(Integer) }
+          attr_accessor :y_
+
+          # A click action.
+          sig do
+            params(
+              button:
+                OpenAI::Responses::ComputerAction::Click::Button::OrSymbol,
+              x: Integer,
+              y_: Integer,
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Indicates which mouse button was pressed during the click. One of `left`,
+            # `right`, `wheel`, `back`, or `forward`.
+            button:,
+            # The x-coordinate where the click occurred.
+            x:,
+            # The y-coordinate where the click occurred.
+            y_:,
+            # Specifies the event type. For a click action, this property is always `click`.
+            type: :click
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                button:
+                  OpenAI::Responses::ComputerAction::Click::Button::OrSymbol,
+                type: Symbol,
+                x: Integer,
+                y_: Integer
+              }
+            )
+          end
+          def to_hash
+          end
+
+          # Indicates which mouse button was pressed during the click. One of `left`,
+          # `right`, `wheel`, `back`, or `forward`.
+          module Button
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, OpenAI::Responses::ComputerAction::Click::Button)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            LEFT =
+              T.let(
+                :left,
+                OpenAI::Responses::ComputerAction::Click::Button::TaggedSymbol
+              )
+            RIGHT =
+              T.let(
+                :right,
+                OpenAI::Responses::ComputerAction::Click::Button::TaggedSymbol
+              )
+            WHEEL =
+              T.let(
+                :wheel,
+                OpenAI::Responses::ComputerAction::Click::Button::TaggedSymbol
+              )
+            BACK =
+              T.let(
+                :back,
+                OpenAI::Responses::ComputerAction::Click::Button::TaggedSymbol
+              )
+            FORWARD =
+              T.let(
+                :forward,
+                OpenAI::Responses::ComputerAction::Click::Button::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Responses::ComputerAction::Click::Button::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        class DoubleClick < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ComputerAction::DoubleClick,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # Specifies the event type. For a double click action, this property is always set
+          # to `double_click`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The x-coordinate where the double click occurred.
+          sig { returns(Integer) }
+          attr_accessor :x
+
+          # The y-coordinate where the double click occurred.
+          sig { returns(Integer) }
+          attr_accessor :y_
+
+          # A double click action.
+          sig do
+            params(x: Integer, y_: Integer, type: Symbol).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # The x-coordinate where the double click occurred.
+            x:,
+            # The y-coordinate where the double click occurred.
+            y_:,
+            # Specifies the event type. For a double click action, this property is always set
+            # to `double_click`.
+            type: :double_click
+          )
+          end
+
+          sig { override.returns({ type: Symbol, x: Integer, y_: Integer }) }
+          def to_hash
+          end
+        end
+
+        class Drag < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ComputerAction::Drag,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # An array of coordinates representing the path of the drag action. Coordinates
+          # will appear as an array of objects, eg
+          #
+          # ```
+          # [
+          #   { x: 100, y: 200 },
+          #   { x: 200, y: 300 }
+          # ]
+          # ```
+          sig do
+            returns(T::Array[OpenAI::Responses::ComputerAction::Drag::Path])
+          end
+          attr_accessor :path
+
+          # Specifies the event type. For a drag action, this property is always set to
+          # `drag`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # A drag action.
+          sig do
+            params(
+              path:
+                T::Array[OpenAI::Responses::ComputerAction::Drag::Path::OrHash],
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # An array of coordinates representing the path of the drag action. Coordinates
+            # will appear as an array of objects, eg
+            #
+            # ```
+            # [
+            #   { x: 100, y: 200 },
+            #   { x: 200, y: 300 }
+            # ]
+            # ```
+            path:,
+            # Specifies the event type. For a drag action, this property is always set to
+            # `drag`.
+            type: :drag
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                path: T::Array[OpenAI::Responses::ComputerAction::Drag::Path],
+                type: Symbol
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Path < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Responses::ComputerAction::Drag::Path,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # The x-coordinate.
+            sig { returns(Integer) }
+            attr_accessor :x
+
+            # The y-coordinate.
+            sig { returns(Integer) }
+            attr_accessor :y_
+
+            # An x/y coordinate pair, e.g. `{ x: 100, y: 200 }`.
+            sig { params(x: Integer, y_: Integer).returns(T.attached_class) }
+            def self.new(
+              # The x-coordinate.
+              x:,
+              # The y-coordinate.
+              y_:
+            )
+            end
+
+            sig { override.returns({ x: Integer, y_: Integer }) }
+            def to_hash
+            end
+          end
+        end
+
+        class Keypress < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ComputerAction::Keypress,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The combination of keys the model is requesting to be pressed. This is an array
+          # of strings, each representing a key.
+          sig { returns(T::Array[String]) }
+          attr_accessor :keys
+
+          # Specifies the event type. For a keypress action, this property is always set to
+          # `keypress`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # A collection of keypresses the model would like to perform.
+          sig do
+            params(keys: T::Array[String], type: Symbol).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # The combination of keys the model is requesting to be pressed. This is an array
+            # of strings, each representing a key.
+            keys:,
+            # Specifies the event type. For a keypress action, this property is always set to
+            # `keypress`.
+            type: :keypress
+          )
+          end
+
+          sig { override.returns({ keys: T::Array[String], type: Symbol }) }
+          def to_hash
+          end
+        end
+
+        class Move < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ComputerAction::Move,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # Specifies the event type. For a move action, this property is always set to
+          # `move`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The x-coordinate to move to.
+          sig { returns(Integer) }
+          attr_accessor :x
+
+          # The y-coordinate to move to.
+          sig { returns(Integer) }
+          attr_accessor :y_
+
+          # A mouse move action.
+          sig do
+            params(x: Integer, y_: Integer, type: Symbol).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # The x-coordinate to move to.
+            x:,
+            # The y-coordinate to move to.
+            y_:,
+            # Specifies the event type. For a move action, this property is always set to
+            # `move`.
+            type: :move
+          )
+          end
+
+          sig { override.returns({ type: Symbol, x: Integer, y_: Integer }) }
+          def to_hash
+          end
+        end
+
+        class Screenshot < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ComputerAction::Screenshot,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # Specifies the event type. For a screenshot action, this property is always set
+          # to `screenshot`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # A screenshot action.
+          sig { params(type: Symbol).returns(T.attached_class) }
+          def self.new(
+            # Specifies the event type. For a screenshot action, this property is always set
+            # to `screenshot`.
+            type: :screenshot
+          )
+          end
+
+          sig { override.returns({ type: Symbol }) }
+          def to_hash
+          end
+        end
+
+        class Scroll < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ComputerAction::Scroll,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The horizontal scroll distance.
+          sig { returns(Integer) }
+          attr_accessor :scroll_x
+
+          # The vertical scroll distance.
+          sig { returns(Integer) }
+          attr_accessor :scroll_y
+
+          # Specifies the event type. For a scroll action, this property is always set to
+          # `scroll`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The x-coordinate where the scroll occurred.
+          sig { returns(Integer) }
+          attr_accessor :x
+
+          # The y-coordinate where the scroll occurred.
+          sig { returns(Integer) }
+          attr_accessor :y_
+
+          # A scroll action.
+          sig do
+            params(
+              scroll_x: Integer,
+              scroll_y: Integer,
+              x: Integer,
+              y_: Integer,
+              type: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The horizontal scroll distance.
+            scroll_x:,
+            # The vertical scroll distance.
+            scroll_y:,
+            # The x-coordinate where the scroll occurred.
+            x:,
+            # The y-coordinate where the scroll occurred.
+            y_:,
+            # Specifies the event type. For a scroll action, this property is always set to
+            # `scroll`.
+            type: :scroll
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                scroll_x: Integer,
+                scroll_y: Integer,
+                type: Symbol,
+                x: Integer,
+                y_: Integer
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        class Type < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ComputerAction::Type,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The text to type.
+          sig { returns(String) }
+          attr_accessor :text
+
+          # Specifies the event type. For a type action, this property is always set to
+          # `type`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # An action to type in text.
+          sig { params(text: String, type: Symbol).returns(T.attached_class) }
+          def self.new(
+            # The text to type.
+            text:,
+            # Specifies the event type. For a type action, this property is always set to
+            # `type`.
+            type: :type
+          )
+          end
+
+          sig { override.returns({ text: String, type: Symbol }) }
+          def to_hash
+          end
+        end
+
+        class Wait < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::ComputerAction::Wait,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # Specifies the event type. For a wait action, this property is always set to
+          # `wait`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # A wait action.
+          sig { params(type: Symbol).returns(T.attached_class) }
+          def self.new(
+            # Specifies the event type. For a wait action, this property is always set to
+            # `wait`.
+            type: :wait
+          )
+          end
+
+          sig { override.returns({ type: Symbol }) }
+          def to_hash
+          end
+        end
+
+        sig do
+          override.returns(
+            T::Array[OpenAI::Responses::ComputerAction::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/computer_action_list.rbi

@@ -0,0 +1,15 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      ComputerActionList =
+        T.let(
+          OpenAI::Internal::Type::ArrayOf[
+            union: OpenAI::Responses::ComputerAction
+          ],
+          OpenAI::Internal::Type::Converter
+        )
+    end
+  end
+end

data/rbi/openai/models/responses/computer_use_tool.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Responses
+      class ComputerUseTool < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(OpenAI::Responses::ComputerUseTool, OpenAI::Internal::AnyHash)
+          end
+
+        # The type of the computer tool. Always `computer`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # A tool that controls a virtual computer. Learn more about the
+        # [computer tool](https://platform.openai.com/docs/guides/tools-computer-use).
+        sig { params(type: Symbol).returns(T.attached_class) }
+        def self.new(
+          # The type of the computer tool. Always `computer`.
+          type: :computer
+        )
+        end
+
+        sig { override.returns({ type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/responses/custom_tool.rbi

@@ -17,6 +17,13 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # Whether this tool should be deferred and discovered via tool search.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :defer_loading
+
+        sig { params(defer_loading: T::Boolean).void }
+        attr_writer :defer_loading
+
         # Optional description of the custom tool, used to provide more context.
         sig { returns(T.nilable(String)) }
         attr_reader :description
@@ -53,6 +60,7 @@ module OpenAI
         sig do
           params(
             name: String,
+            defer_loading: T::Boolean,
             description: String,
             format_:
               T.any(
@@ -65,6 +73,8 @@ module OpenAI
         def self.new(
           # The name of the custom tool, used to identify it in tool calls.
           name:,
+          # Whether this tool should be deferred and discovered via tool search.
+          defer_loading: nil,
           # Optional description of the custom tool, used to provide more context.
           description: nil,
           # The input format for the custom tool. Default is unconstrained text.
@@ -79,6 +89,7 @@ module OpenAI
             {
               name: String,
               type: Symbol,
+              defer_loading: T::Boolean,
               description: String,
               format_:
                 T.any(

data/rbi/openai/models/responses/easy_input_message.rbi

@@ -22,6 +22,17 @@ module OpenAI
         sig { returns(OpenAI::Responses::EasyInputMessage::Role::OrSymbol) }
         attr_accessor :role
 
+        # Labels an `assistant` message as intermediate commentary (`commentary`) or the
+        # final answer (`final_answer`). For models like `gpt-5.3-codex` and beyond, when
+        # sending follow-up requests, preserve and resend phase on all assistant messages
+        # — dropping it can degrade performance. Not used for user messages.
+        sig do
+          returns(
+            T.nilable(OpenAI::Responses::EasyInputMessage::Phase::OrSymbol)
+          )
+        end
+        attr_accessor :phase
+
         # The type of the message input. Always `message`.
         sig do
           returns(
@@ -44,6 +55,8 @@ module OpenAI
           params(
             content: OpenAI::Responses::EasyInputMessage::Content::Variants,
             role: OpenAI::Responses::EasyInputMessage::Role::OrSymbol,
+            phase:
+              T.nilable(OpenAI::Responses::EasyInputMessage::Phase::OrSymbol),
             type: OpenAI::Responses::EasyInputMessage::Type::OrSymbol
           ).returns(T.attached_class)
         end
@@ -54,6 +67,11 @@ module OpenAI
           # The role of the message input. One of `user`, `assistant`, `system`, or
           # `developer`.
           role:,
+          # Labels an `assistant` message as intermediate commentary (`commentary`) or the
+          # final answer (`final_answer`). For models like `gpt-5.3-codex` and beyond, when
+          # sending follow-up requests, preserve and resend phase on all assistant messages
+          # — dropping it can degrade performance. Not used for user messages.
+          phase: nil,
           # The type of the message input. Always `message`.
           type: nil
         )
@@ -64,6 +82,8 @@ module OpenAI
             {
               content: OpenAI::Responses::EasyInputMessage::Content::Variants,
               role: OpenAI::Responses::EasyInputMessage::Role::OrSymbol,
+              phase:
+                T.nilable(OpenAI::Responses::EasyInputMessage::Phase::OrSymbol),
               type: OpenAI::Responses::EasyInputMessage::Type::OrSymbol
             }
           )
@@ -134,6 +154,39 @@ module OpenAI
           end
         end
 
+        # Labels an `assistant` message as intermediate commentary (`commentary`) or the
+        # final answer (`final_answer`). For models like `gpt-5.3-codex` and beyond, when
+        # sending follow-up requests, preserve and resend phase on all assistant messages
+        # — dropping it can degrade performance. Not used for user messages.
+        module Phase
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, OpenAI::Responses::EasyInputMessage::Phase)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          COMMENTARY =
+            T.let(
+              :commentary,
+              OpenAI::Responses::EasyInputMessage::Phase::TaggedSymbol
+            )
+          FINAL_ANSWER =
+            T.let(
+              :final_answer,
+              OpenAI::Responses::EasyInputMessage::Phase::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[OpenAI::Responses::EasyInputMessage::Phase::TaggedSymbol]
+            )
+          end
+          def self.values
+          end
+        end
+
         # The type of the message input. Always `message`.
         module Type
           extend OpenAI::Internal::Type::Enum