openai 0.92.0 → 0.93.0

data/sig/openai/models/beta/beta_computer_action.rbs

@@ -27,16 +27,33 @@ module OpenAI
           }
 
         class Click < OpenAI::Internal::Type::BaseModel
+          # Indicates which mouse button was pressed during the click. One of `left`,
+          # `right`, `wheel`, `back`, or `forward`.
           attr_accessor button: OpenAI::Models::Beta::BetaComputerAction::Click::button
 
+          # Specifies the event type. For a click action, this property is always `click`.
           attr_accessor type: :click
 
+          # The x-coordinate where the click occurred.
           attr_accessor x: Integer
 
+          # The y-coordinate where the click occurred.
           attr_accessor y_: Integer
 
+          # The keys being held while clicking.
           attr_accessor keys: ::Array[String]?
 
+          # @param button
+          #   Indicates which mouse button was pressed during the click. One of `left`,
+          #   `right`, `wheel`, `back`, or `forward`.
+          # @param x
+          #   The x-coordinate where the click occurred.
+          # @param y_
+          #   The y-coordinate where the click occurred.
+          # @param keys
+          #   The keys being held while clicking.
+          # @param type
+          #   Specifies the event type. For a click action, this property is always `click`.
           def initialize: (
             button: OpenAI::Models::Beta::BetaComputerAction::Click::button,
             x: Integer,
@@ -77,14 +94,28 @@ module OpenAI
           }
 
         class DoubleClick < OpenAI::Internal::Type::BaseModel
+          # The keys being held while double-clicking.
           attr_accessor keys: ::Array[String]?
 
+          # Specifies the event type. For a double click action, this property is always set
+          # to `double_click`.
           attr_accessor type: :double_click
 
+          # The x-coordinate where the double click occurred.
           attr_accessor x: Integer
 
+          # The y-coordinate where the double click occurred.
           attr_accessor y_: Integer
 
+          # @param keys
+          #   The keys being held while double-clicking.
+          # @param x
+          #   The x-coordinate where the double click occurred.
+          # @param y_
+          #   The y-coordinate where the double click occurred.
+          # @param type
+          #   Specifies the event type. For a double click action, this property is always set
+          #   to `double_click`.
           def initialize: (
             keys: ::Array[String]?,
             x: Integer,
@@ -108,12 +139,39 @@ module OpenAI
           }
 
         class Drag < OpenAI::Internal::Type::BaseModel
+          # 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 }
+          # ]
+          # ```
           attr_accessor path: ::Array[OpenAI::Beta::BetaComputerAction::Drag::Path]
 
+          # Specifies the event type. For a drag action, this property is always set to
+          # `drag`.
           attr_accessor type: :drag
 
+          # The keys being held while dragging the mouse.
           attr_accessor keys: ::Array[String]?
 
+          # @param path
+          #   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 }
+          #   ]
+          #   ```
+          # @param keys
+          #   The keys being held while dragging the mouse.
+          # @param type
+          #   Specifies the event type. For a drag action, this property is always set to
+          #   `drag`.
           def initialize: (
             path: ::Array[OpenAI::Beta::BetaComputerAction::Drag::Path],
             ?keys: ::Array[String]?,
@@ -129,10 +187,16 @@ module OpenAI
           type path = { x: Integer, y_: Integer }
 
           class Path < OpenAI::Internal::Type::BaseModel
+            # The x-coordinate.
             attr_accessor x: Integer
 
+            # The y-coordinate.
             attr_accessor y_: Integer
 
+            # @param x
+            #   The x-coordinate.
+            # @param y_
+            #   The y-coordinate.
             def initialize: (x: Integer, y_: Integer) -> void
 
             def to_hash: -> { x: Integer, y_: Integer }
@@ -142,10 +206,20 @@ module OpenAI
         type keypress = { keys: ::Array[String], ?type: :keypress }
 
         class Keypress < OpenAI::Internal::Type::BaseModel
+          # The combination of keys the model is requesting to be pressed. This is an array
+          # of strings, each representing a key.
           attr_accessor keys: ::Array[String]
 
+          # Specifies the event type. For a keypress action, this property is always set to
+          # `keypress`.
           attr_accessor type: :keypress
 
+          # @param keys
+          #   The combination of keys the model is requesting to be pressed. This is an array
+          #   of strings, each representing a key.
+          # @param type
+          #   Specifies the event type. For a keypress action, this property is always set to
+          #   `keypress`.
           def initialize: (keys: ::Array[String], ?type: :keypress) -> void
 
           def to_hash: -> { keys: ::Array[String], ?type: :keypress }
@@ -155,14 +229,28 @@ module OpenAI
           { ?type: :move, x: Integer, y_: Integer, ?keys: ::Array[String]? }
 
         class Move < OpenAI::Internal::Type::BaseModel
+          # Specifies the event type. For a move action, this property is always set to
+          # `move`.
           attr_accessor type: :move
 
+          # The x-coordinate to move to.
           attr_accessor x: Integer
 
+          # The y-coordinate to move to.
           attr_accessor y_: Integer
 
+          # The keys being held while moving the mouse.
           attr_accessor keys: ::Array[String]?
 
+          # @param x
+          #   The x-coordinate to move to.
+          # @param y_
+          #   The y-coordinate to move to.
+          # @param keys
+          #   The keys being held while moving the mouse.
+          # @param type
+          #   Specifies the event type. For a move action, this property is always set to
+          #   `move`.
           def initialize: (
             x: Integer,
             y_: Integer,
@@ -181,8 +269,13 @@ module OpenAI
         type screenshot = { ?type: :screenshot }
 
         class Screenshot < OpenAI::Internal::Type::BaseModel
+          # Specifies the event type. For a screenshot action, this property is always set
+          # to `screenshot`.
           attr_accessor type: :screenshot
 
+          # @param type
+          #   Specifies the event type. For a screenshot action, this property is always set
+          #   to `screenshot`.
           def initialize: (?type: :screenshot) -> void
 
           def to_hash: -> { ?type: :screenshot }
@@ -199,18 +292,38 @@ module OpenAI
           }
 
         class Scroll < OpenAI::Internal::Type::BaseModel
+          # The horizontal scroll distance.
           attr_accessor scroll_x: Integer
 
+          # The vertical scroll distance.
           attr_accessor scroll_y: Integer
 
+          # Specifies the event type. For a scroll action, this property is always set to
+          # `scroll`.
           attr_accessor type: :scroll
 
+          # The x-coordinate where the scroll occurred.
           attr_accessor x: Integer
 
+          # The y-coordinate where the scroll occurred.
           attr_accessor y_: Integer
 
+          # The keys being held while scrolling.
           attr_accessor keys: ::Array[String]?
 
+          # @param scroll_x
+          #   The horizontal scroll distance.
+          # @param scroll_y
+          #   The vertical scroll distance.
+          # @param x
+          #   The x-coordinate where the scroll occurred.
+          # @param y_
+          #   The y-coordinate where the scroll occurred.
+          # @param keys
+          #   The keys being held while scrolling.
+          # @param type
+          #   Specifies the event type. For a scroll action, this property is always set to
+          #   `scroll`.
           def initialize: (
             scroll_x: Integer,
             scroll_y: Integer,
@@ -233,10 +346,18 @@ module OpenAI
         type type_ = { text: String, ?type: :type }
 
         class Type < OpenAI::Internal::Type::BaseModel
+          # The text to type.
           attr_accessor text: String
 
+          # Specifies the event type. For a type action, this property is always set to
+          # `type`.
           attr_accessor type: :type
 
+          # @param text
+          #   The text to type.
+          # @param type
+          #   Specifies the event type. For a type action, this property is always set to
+          #   `type`.
           def initialize: (text: String, ?type: :type) -> void
 
           def to_hash: -> { text: String, ?type: :type }
@@ -245,8 +366,13 @@ module OpenAI
         type wait = { ?type: :wait }
 
         class Wait < OpenAI::Internal::Type::BaseModel
+          # Specifies the event type. For a wait action, this property is always set to
+          # `wait`.
           attr_accessor type: :wait
 
+          # @param type
+          #   Specifies the event type. For a wait action, this property is always set to
+          #   `wait`.
           def initialize: (?type: :wait) -> void
 
           def to_hash: -> { ?type: :wait }

data/sig/openai/models/beta/beta_computer_tool.rbs

@@ -6,8 +6,11 @@ module OpenAI
       type beta_computer_tool = { ?type: :computer }
 
       class BetaComputerTool < OpenAI::Internal::Type::BaseModel
+        # The type of the computer tool. Always `computer`.
         attr_accessor type: :computer
 
+        # @param type
+        #   The type of the computer tool. Always `computer`.
         def initialize: (?type: :computer) -> void
 
         def to_hash: -> { ?type: :computer }

data/sig/openai/models/beta/beta_computer_use_preview_tool.rbs

@@ -12,14 +12,26 @@ module OpenAI
         }
 
       class BetaComputerUsePreviewTool < OpenAI::Internal::Type::BaseModel
+        # The height of the computer display.
         attr_accessor display_height: Integer
 
+        # The width of the computer display.
         attr_accessor display_width: Integer
 
+        # The type of computer environment to control.
         attr_accessor environment: OpenAI::Models::Beta::BetaComputerUsePreviewTool::environment
 
+        # The type of the computer use tool. Always `computer_use_preview`.
         attr_accessor type: :computer_use_preview
 
+        # @param display_height
+        #   The height of the computer display.
+        # @param display_width
+        #   The width of the computer display.
+        # @param environment
+        #   The type of computer environment to control.
+        # @param type
+        #   The type of the computer use tool. Always `computer_use_preview`.
         def initialize: (
           display_height: Integer,
           display_width: Integer,

data/sig/openai/models/beta/beta_container_auto.rbs

@@ -13,26 +13,44 @@ module OpenAI
         }
 
       class BetaContainerAuto < OpenAI::Internal::Type::BaseModel
+        # Automatically creates a container for this request
         attr_accessor type: :container_auto
 
+        # An optional list of uploaded files to make available to your code.
         attr_reader file_ids: ::Array[String]?
 
+        # An optional list of uploaded files to make available to your code.
         def file_ids=: (::Array[String]) -> ::Array[String]
 
+        # The memory limit for the container.
         attr_accessor memory_limit: OpenAI::Models::Beta::BetaContainerAuto::memory_limit?
 
+        # Network access policy for the container.
         attr_reader network_policy: OpenAI::Models::Beta::BetaContainerAuto::network_policy?
 
+        # Network access policy for the container.
         def network_policy=: (
           OpenAI::Models::Beta::BetaContainerAuto::network_policy
         ) -> OpenAI::Models::Beta::BetaContainerAuto::network_policy
 
+        # An optional list of skills referenced by id or inline data.
         attr_reader skills: ::Array[OpenAI::Models::Beta::BetaContainerAuto::skill]?
 
+        # An optional list of skills referenced by id or inline data.
         def skills=: (
           ::Array[OpenAI::Models::Beta::BetaContainerAuto::skill]
         ) -> ::Array[OpenAI::Models::Beta::BetaContainerAuto::skill]
 
+        # @param file_ids
+        #   An optional list of uploaded files to make available to your code.
+        # @param memory_limit
+        #   The memory limit for the container.
+        # @param network_policy
+        #   Network access policy for the container.
+        # @param skills
+        #   An optional list of skills referenced by id or inline data.
+        # @param type
+        #   Automatically creates a container for this request
         def initialize: (
           ?file_ids: ::Array[String],
           ?memory_limit: OpenAI::Models::Beta::BetaContainerAuto::memory_limit?,

data/sig/openai/models/beta/beta_container_network_policy_allowlist.rbs

@@ -11,16 +11,26 @@ module OpenAI
         }
 
       class BetaContainerNetworkPolicyAllowlist < OpenAI::Internal::Type::BaseModel
+        # A list of allowed domains when type is `allowlist`.
         attr_accessor allowed_domains: ::Array[String]
 
+        # Allow outbound network access only to specified domains. Always `allowlist`.
         attr_accessor type: :allowlist
 
+        # Optional domain-scoped secrets for allowlisted domains.
         attr_reader domain_secrets: ::Array[OpenAI::Beta::BetaContainerNetworkPolicyDomainSecret]?
 
+        # Optional domain-scoped secrets for allowlisted domains.
         def domain_secrets=: (
           ::Array[OpenAI::Beta::BetaContainerNetworkPolicyDomainSecret]
         ) -> ::Array[OpenAI::Beta::BetaContainerNetworkPolicyDomainSecret]
 
+        # @param allowed_domains
+        #   A list of allowed domains when type is `allowlist`.
+        # @param domain_secrets
+        #   Optional domain-scoped secrets for allowlisted domains.
+        # @param type
+        #   Allow outbound network access only to specified domains. Always `allowlist`.
         def initialize: (
           allowed_domains: ::Array[String],
           ?domain_secrets: ::Array[OpenAI::Beta::BetaContainerNetworkPolicyDomainSecret],

data/sig/openai/models/beta/beta_container_network_policy_disabled.rbs

@@ -6,8 +6,11 @@ module OpenAI
       type beta_container_network_policy_disabled = { ?type: :disabled }
 
       class BetaContainerNetworkPolicyDisabled < OpenAI::Internal::Type::BaseModel
+        # Disable outbound network access. Always `disabled`.
         attr_accessor type: :disabled
 
+        # @param type
+        #   Disable outbound network access. Always `disabled`.
         def initialize: (?type: :disabled) -> void
 
         def to_hash: -> { ?type: :disabled }

data/sig/openai/models/beta/beta_container_network_policy_domain_secret.rbs

@@ -7,12 +7,21 @@ module OpenAI
         { domain: String, name: String, value: String }
 
       class BetaContainerNetworkPolicyDomainSecret < OpenAI::Internal::Type::BaseModel
+        # The domain associated with the secret.
         attr_accessor domain: String
 
+        # The name of the secret to inject for the domain.
         attr_accessor name: String
 
+        # The secret value to inject for the domain.
         attr_accessor value: String
 
+        # @param domain
+        #   The domain associated with the secret.
+        # @param name
+        #   The name of the secret to inject for the domain.
+        # @param value
+        #   The secret value to inject for the domain.
         def initialize: (domain: String, name: String, value: String) -> void
 
         def to_hash: -> { domain: String, name: String, value: String }

data/sig/openai/models/beta/beta_container_reference.rbs

@@ -7,10 +7,16 @@ module OpenAI
         { container_id: String, ?type: :container_reference }
 
       class BetaContainerReference < OpenAI::Internal::Type::BaseModel
+        # The ID of the referenced container.
         attr_accessor container_id: String
 
+        # References a container created with the /v1/containers endpoint
         attr_accessor type: :container_reference
 
+        # @param container_id
+        #   The ID of the referenced container.
+        # @param type
+        #   References a container created with the /v1/containers endpoint
         def initialize: (
           container_id: String,
           ?type: :container_reference

data/sig/openai/models/beta/beta_custom_tool.rbs

@@ -15,30 +15,58 @@ module OpenAI
         }
 
       class BetaCustomTool < OpenAI::Internal::Type::BaseModel
+        # The name of the custom tool, used to identify it in tool calls.
         attr_accessor name: String
 
+        # The type of the custom tool. Always `custom`.
         attr_accessor type: :custom
 
+        # The tool invocation context(s).
         attr_accessor allowed_callers: ::Array[OpenAI::Models::Beta::BetaCustomTool::allowed_caller]?
 
+        # Whether the tool response can be returned asynchronously versus immediately
+        # returned on next response creation.
         attr_reader async: bool?
 
+        # Whether the tool response can be returned asynchronously versus immediately
+        # returned on next response creation.
         def async=: (bool) -> bool
 
+        # Whether this tool should be deferred and discovered via tool search.
         attr_reader defer_loading: bool?
 
+        # Whether this tool should be deferred and discovered via tool search.
         def defer_loading=: (bool) -> bool
 
+        # Optional description of the custom tool, used to provide more context.
         attr_reader description: String?
 
+        # Optional description of the custom tool, used to provide more context.
         def description=: (String) -> String
 
+        # The input format for the custom tool. Default is unconstrained text.
         attr_reader format_: OpenAI::Models::Beta::BetaCustomTool::format_?
 
+        # The input format for the custom tool. Default is unconstrained text.
         def format_=: (
           OpenAI::Models::Beta::BetaCustomTool::format_
         ) -> OpenAI::Models::Beta::BetaCustomTool::format_
 
+        # @param name
+        #   The name of the custom tool, used to identify it in tool calls.
+        # @param allowed_callers
+        #   The tool invocation context(s).
+        # @param async
+        #   Whether the tool response can be returned asynchronously versus immediately
+        #   returned on next response creation.
+        # @param defer_loading
+        #   Whether this tool should be deferred and discovered via tool search.
+        # @param description
+        #   Optional description of the custom tool, used to provide more context.
+        # @param format_
+        #   The input format for the custom tool. Default is unconstrained text.
+        # @param type
+        #   The type of the custom tool. Always `custom`.
         def initialize: (
           name: String,
           ?allowed_callers: ::Array[OpenAI::Models::Beta::BetaCustomTool::allowed_caller]?,
@@ -80,8 +108,11 @@ module OpenAI
           type text = { ?type: :text }
 
           class Text < OpenAI::Internal::Type::BaseModel
+            # Unconstrained text format. Always `text`.
             attr_accessor type: :text
 
+            # @param type
+            #   Unconstrained text format. Always `text`.
             def initialize: (?type: :text) -> void
 
             def to_hash: -> { ?type: :text }
@@ -95,12 +126,21 @@ module OpenAI
             }
 
           class Grammar < OpenAI::Internal::Type::BaseModel
+            # The grammar definition.
             attr_accessor definition: String
 
+            # The syntax of the grammar definition. One of `lark` or `regex`.
             attr_accessor syntax: OpenAI::Models::Beta::BetaCustomTool::Format::Grammar::syntax
 
+            # Grammar format. Always `grammar`.
             attr_accessor type: :grammar
 
+            # @param definition
+            #   The grammar definition.
+            # @param syntax
+            #   The syntax of the grammar definition. One of `lark` or `regex`.
+            # @param type
+            #   Grammar format. Always `grammar`.
             def initialize: (
               definition: String,
               syntax: OpenAI::Models::Beta::BetaCustomTool::Format::Grammar::syntax,

data/sig/openai/models/beta/beta_easy_input_message.rbs

@@ -12,18 +12,41 @@ module OpenAI
         }
 
       class BetaEasyInputMessage < OpenAI::Internal::Type::BaseModel
+        # Text, image, or audio input to the model, used to generate a response. Can also
+        # contain previous assistant responses.
         attr_accessor content: OpenAI::Models::Beta::BetaEasyInputMessage::content
 
+        # The role of the message input. One of `user`, `assistant`, `system`, or
+        # `developer`.
         attr_accessor role: OpenAI::Models::Beta::BetaEasyInputMessage::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.
         attr_accessor phase: OpenAI::Models::Beta::BetaEasyInputMessage::phase?
 
+        # The type of the message input. Always `message`.
         attr_reader type: OpenAI::Models::Beta::BetaEasyInputMessage::type_?
 
+        # The type of the message input. Always `message`.
         def type=: (
           OpenAI::Models::Beta::BetaEasyInputMessage::type_
         ) -> OpenAI::Models::Beta::BetaEasyInputMessage::type_
 
+        # @param content
+        #   Text, image, or audio input to the model, used to generate a response. Can also
+        #   contain previous assistant responses.
+        # @param role
+        #   The role of the message input. One of `user`, `assistant`, `system`, or
+        #   `developer`.
+        # @param phase
+        #   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.
+        # @param type
+        #   The type of the message input. Always `message`.
         def initialize: (
           content: OpenAI::Models::Beta::BetaEasyInputMessage::content,
           role: OpenAI::Models::Beta::BetaEasyInputMessage::role,