openai 0.92.0 → 0.93.0

data/sig/openai/models/responses/computer_action.rbs

@@ -25,16 +25,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::Responses::ComputerAction::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::Responses::ComputerAction::Click::button,
             x: Integer,
@@ -75,14 +92,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,
@@ -106,12 +137,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::Responses::ComputerAction::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::Responses::ComputerAction::Drag::Path],
             ?keys: ::Array[String]?,
@@ -127,10 +185,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 }
@@ -140,10 +204,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 }
@@ -153,14 +227,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,
@@ -179,8 +267,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 }
@@ -197,18 +290,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,
@@ -231,10 +344,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 }
@@ -243,8 +364,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/responses/computer_tool.rbs

@@ -4,8 +4,11 @@ module OpenAI
       type computer_tool = { ?type: :computer }
 
       class ComputerTool < 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/responses/computer_use_preview_tool.rbs

@@ -10,14 +10,26 @@ module OpenAI
         }
 
       class ComputerUsePreviewTool < 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::Responses::ComputerUsePreviewTool::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/responses/container_auto.rbs

@@ -11,26 +11,44 @@ module OpenAI
         }
 
       class ContainerAuto < 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::Responses::ContainerAuto::memory_limit?
 
+        # Network access policy for the container.
         attr_reader network_policy: OpenAI::Models::Responses::ContainerAuto::network_policy?
 
+        # Network access policy for the container.
         def network_policy=: (
           OpenAI::Models::Responses::ContainerAuto::network_policy
         ) -> OpenAI::Models::Responses::ContainerAuto::network_policy
 
+        # An optional list of skills referenced by id or inline data.
         attr_reader skills: ::Array[OpenAI::Models::Responses::ContainerAuto::skill]?
 
+        # An optional list of skills referenced by id or inline data.
         def skills=: (
           ::Array[OpenAI::Models::Responses::ContainerAuto::skill]
         ) -> ::Array[OpenAI::Models::Responses::ContainerAuto::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::Responses::ContainerAuto::memory_limit?,

data/sig/openai/models/responses/container_network_policy_allowlist.rbs

@@ -9,16 +9,26 @@ module OpenAI
         }
 
       class ContainerNetworkPolicyAllowlist < 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::Responses::ContainerNetworkPolicyDomainSecret]?
 
+        # Optional domain-scoped secrets for allowlisted domains.
         def domain_secrets=: (
           ::Array[OpenAI::Responses::ContainerNetworkPolicyDomainSecret]
         ) -> ::Array[OpenAI::Responses::ContainerNetworkPolicyDomainSecret]
 
+        # @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::Responses::ContainerNetworkPolicyDomainSecret],

data/sig/openai/models/responses/container_network_policy_disabled.rbs

@@ -4,8 +4,11 @@ module OpenAI
       type container_network_policy_disabled = { ?type: :disabled }
 
       class ContainerNetworkPolicyDisabled < 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/responses/container_network_policy_domain_secret.rbs

@@ -5,12 +5,21 @@ module OpenAI
         { domain: String, name: String, value: String }
 
       class ContainerNetworkPolicyDomainSecret < 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/responses/container_reference.rbs

@@ -5,10 +5,16 @@ module OpenAI
         { container_id: String, ?type: :container_reference }
 
       class ContainerReference < 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/responses/custom_tool.rbs

@@ -13,30 +13,58 @@ module OpenAI
         }
 
       class CustomTool < 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::Responses::CustomTool::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::custom_tool_input_format?
 
+        # The input format for the custom tool. Default is unconstrained text.
         def format_=: (
           OpenAI::Models::custom_tool_input_format
         ) -> OpenAI::Models::custom_tool_input_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::Responses::CustomTool::allowed_caller]?,

data/sig/openai/models/responses/easy_input_message.rbs

@@ -10,18 +10,41 @@ module OpenAI
         }
 
       class EasyInputMessage < 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::Responses::EasyInputMessage::content
 
+        # The role of the message input. One of `user`, `assistant`, `system`, or
+        # `developer`.
         attr_accessor role: OpenAI::Models::Responses::EasyInputMessage::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::Responses::EasyInputMessage::phase?
 
+        # The type of the message input. Always `message`.
         attr_reader type: OpenAI::Models::Responses::EasyInputMessage::type_?
 
+        # The type of the message input. Always `message`.
         def type=: (
           OpenAI::Models::Responses::EasyInputMessage::type_
         ) -> OpenAI::Models::Responses::EasyInputMessage::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::Responses::EasyInputMessage::content,
           role: OpenAI::Models::Responses::EasyInputMessage::role,

data/sig/openai/models/responses/file_search_tool.rbs

@@ -11,22 +11,42 @@ module OpenAI
         }
 
       class FileSearchTool < OpenAI::Internal::Type::BaseModel
+        # The type of the file search tool. Always `file_search`.
         attr_accessor type: :file_search
 
+        # The IDs of the vector stores to search.
         attr_accessor vector_store_ids: ::Array[String]
 
+        # A filter to apply.
         attr_accessor filters: OpenAI::Models::Responses::FileSearchTool::filters?
 
+        # The maximum number of results to return. This number should be between 1 and 50
+        # inclusive.
         attr_reader max_num_results: Integer?
 
+        # The maximum number of results to return. This number should be between 1 and 50
+        # inclusive.
         def max_num_results=: (Integer) -> Integer
 
+        # Ranking options for search.
         attr_reader ranking_options: OpenAI::Responses::FileSearchTool::RankingOptions?
 
+        # Ranking options for search.
         def ranking_options=: (
           OpenAI::Responses::FileSearchTool::RankingOptions
         ) -> OpenAI::Responses::FileSearchTool::RankingOptions
 
+        # @param vector_store_ids
+        #   The IDs of the vector stores to search.
+        # @param filters
+        #   A filter to apply.
+        # @param max_num_results
+        #   The maximum number of results to return. This number should be between 1 and 50
+        #   inclusive.
+        # @param ranking_options
+        #   Ranking options for search.
+        # @param type
+        #   The type of the file search tool. Always `file_search`.
         def initialize: (
           vector_store_ids: ::Array[String],
           ?filters: OpenAI::Models::Responses::FileSearchTool::filters?,
@@ -59,22 +79,43 @@ module OpenAI
           }
 
         class RankingOptions < OpenAI::Internal::Type::BaseModel
+          # Weights that control how reciprocal rank fusion balances semantic embedding
+          # matches versus sparse keyword matches when hybrid search is enabled.
           attr_reader hybrid_search: OpenAI::Responses::FileSearchTool::RankingOptions::HybridSearch?
 
+          # Weights that control how reciprocal rank fusion balances semantic embedding
+          # matches versus sparse keyword matches when hybrid search is enabled.
           def hybrid_search=: (
             OpenAI::Responses::FileSearchTool::RankingOptions::HybridSearch
           ) -> OpenAI::Responses::FileSearchTool::RankingOptions::HybridSearch
 
+          # The ranker to use for the file search.
           attr_reader ranker: OpenAI::Models::Responses::FileSearchTool::RankingOptions::ranker?
 
+          # The ranker to use for the file search.
           def ranker=: (
             OpenAI::Models::Responses::FileSearchTool::RankingOptions::ranker
           ) -> OpenAI::Models::Responses::FileSearchTool::RankingOptions::ranker
 
+          # The score threshold for the file search, a number between 0 and 1. Numbers
+          # closer to 1 will attempt to return only the most relevant results, but may
+          # return fewer results.
           attr_reader score_threshold: Float?
 
+          # The score threshold for the file search, a number between 0 and 1. Numbers
+          # closer to 1 will attempt to return only the most relevant results, but may
+          # return fewer results.
           def score_threshold=: (Float) -> Float
 
+          # @param hybrid_search
+          #   Weights that control how reciprocal rank fusion balances semantic embedding
+          #   matches versus sparse keyword matches when hybrid search is enabled.
+          # @param ranker
+          #   The ranker to use for the file search.
+          # @param score_threshold
+          #   The score threshold for the file search, a number between 0 and 1. Numbers
+          #   closer to 1 will attempt to return only the most relevant results, but may
+          #   return fewer results.
           def initialize: (
             ?hybrid_search: OpenAI::Responses::FileSearchTool::RankingOptions::HybridSearch,
             ?ranker: OpenAI::Models::Responses::FileSearchTool::RankingOptions::ranker,
@@ -90,10 +131,16 @@ module OpenAI
           type hybrid_search = { embedding_weight: Float, text_weight: Float }
 
           class HybridSearch < OpenAI::Internal::Type::BaseModel
+            # The weight of the embedding in the reciprocal ranking fusion.
             attr_accessor embedding_weight: Float
 
+            # The weight of the text in the reciprocal ranking fusion.
             attr_accessor text_weight: Float
 
+            # @param embedding_weight
+            #   The weight of the embedding in the reciprocal ranking fusion.
+            # @param text_weight
+            #   The weight of the text in the reciprocal ranking fusion.
             def initialize: (
               embedding_weight: Float,
               text_weight: Float

data/sig/openai/models/responses/function_shell_tool.rbs

@@ -9,12 +9,18 @@ module OpenAI
         }
 
       class FunctionShellTool < OpenAI::Internal::Type::BaseModel
+        # The type of the shell tool. Always `shell`.
         attr_accessor type: :shell
 
+        # The tool invocation context(s).
         attr_accessor allowed_callers: ::Array[OpenAI::Models::Responses::FunctionShellTool::allowed_caller]?
 
         attr_accessor environment: OpenAI::Models::Responses::FunctionShellTool::environment?
 
+        # @param allowed_callers
+        #   The tool invocation context(s).
+        # @param type
+        #   The type of the shell tool. Always `shell`.
         def initialize: (
           ?allowed_callers: ::Array[OpenAI::Models::Responses::FunctionShellTool::allowed_caller]?,
           ?environment: OpenAI::Models::Responses::FunctionShellTool::environment?,