openai 0.92.0 → 0.93.0

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

@@ -18,22 +18,112 @@ module OpenAI
         extend OpenAI::Internal::Type::RequestParameters::Converter
         include OpenAI::Internal::Type::RequestParameters
 
+        # Model ID used to generate the response, like `gpt-6-astra`. OpenAI offers a wide
+        # range of models with different capabilities, performance characteristics, and
+        # price points. Refer to the
+        # [model guide](https://developers.openai.com/api/docs/models) to browse and
+        # compare available models.
         attr_accessor model: OpenAI::Models::Responses::ResponseCompactParams::model?
 
+        # Text, image, or file inputs to the model, used to generate a response
         attr_accessor input: OpenAI::Models::Responses::ResponseCompactParams::input?
 
+        # A system (or developer) message inserted into the model's context. When used
+        # along with `previous_response_id`, the instructions from a previous response
+        # will not be carried over to the next response. This makes it simple to swap out
+        # system (or developer) messages in new responses.
         attr_accessor instructions: String?
 
+        # The unique ID of the previous response to the model. Use this to create
+        # multi-turn conversations. Learn more about
+        # [conversation state](https://developers.openai.com/api/docs/guides/conversation-state).
+        # Cannot be used in conjunction with `conversation`.
         attr_accessor previous_response_id: String?
 
+        # A key to use when reading from or writing to the prompt cache.
         attr_accessor prompt_cache_key: String?
 
+        # Options for prompt caching. Supported for `gpt-5.6` and later models. By
+        # default, OpenAI automatically chooses one implicit cache breakpoint. You can add
+        # explicit breakpoints to content blocks with `prompt_cache_breakpoint`. Each
+        # request can write up to four breakpoints. For cache matching, OpenAI considers
+        # up to the latest 80 breakpoints in the conversation, without a content-block
+        # lookback limit. Set `mode` to `explicit` to disable the implicit breakpoint. The
+        # `ttl` defaults to `30m`, which is currently the only supported value. See the
+        # [prompt caching guide](https://developers.openai.com/api/docs/guides/prompt-caching)
+        # for current details.
         attr_accessor prompt_cache_options: OpenAI::Responses::ResponseCompactParams::PromptCacheOptions?
 
+        # How long to retain a prompt cache entry created by this request.
         attr_accessor prompt_cache_retention: OpenAI::Models::Responses::ResponseCompactParams::prompt_cache_retention?
 
+        # Specifies the processing type used for serving the request. - If set to 'auto',
+        # then the request will be processed with the service tier configured in the
+        # Project settings. Unless otherwise configured, the Project will use 'default'. -
+        # If set to 'default', then the request will be processed with the standard
+        # pricing and performance for the selected model. - If set to
+        # '[flex](https://developers.openai.com/api/docs/guides/flex-processing)', then
+        # the request will be processed with the Flex Processing service tier. - To opt-in
+        # to [Fast mode](https://developers.openai.com/api/docs/guides/fast-mode) at the
+        # request level, include the `service_tier=fast` or `service_tier=priority`
+        # parameter for Responses or Chat Completions. For models with a dedicated Fast
+        # tier, either value resolves to `service_tier=fast`; for other models, either
+        # value resolves to `service_tier=priority`. - When not set, the default behavior
+        # is 'auto'. When the `service_tier` parameter is set, the response body will
+        # include the `service_tier` value based on the processing mode actually used to
+        # serve the request. This response value may be different from the value set in
+        # the parameter.
         attr_accessor service_tier: OpenAI::Models::Responses::ResponseCompactParams::service_tier?
 
+        # @param model
+        #   Model ID used to generate the response, like `gpt-6-astra`. OpenAI offers a wide
+        #   range of models with different capabilities, performance characteristics, and
+        #   price points. Refer to the
+        #   [model guide](https://developers.openai.com/api/docs/models) to browse and
+        #   compare available models.
+        # @param input
+        #   Text, image, or file inputs to the model, used to generate a response
+        # @param instructions
+        #   A system (or developer) message inserted into the model's context. When used
+        #   along with `previous_response_id`, the instructions from a previous response
+        #   will not be carried over to the next response. This makes it simple to swap out
+        #   system (or developer) messages in new responses.
+        # @param previous_response_id
+        #   The unique ID of the previous response to the model. Use this to create
+        #   multi-turn conversations. Learn more about
+        #   [conversation state](https://developers.openai.com/api/docs/guides/conversation-state).
+        #   Cannot be used in conjunction with `conversation`.
+        # @param prompt_cache_key
+        #   A key to use when reading from or writing to the prompt cache.
+        # @param prompt_cache_options
+        #   Options for prompt caching. Supported for `gpt-5.6` and later models. By
+        #   default, OpenAI automatically chooses one implicit cache breakpoint. You can add
+        #   explicit breakpoints to content blocks with `prompt_cache_breakpoint`. Each
+        #   request can write up to four breakpoints. For cache matching, OpenAI considers
+        #   up to the latest 80 breakpoints in the conversation, without a content-block
+        #   lookback limit. Set `mode` to `explicit` to disable the implicit breakpoint. The
+        #   `ttl` defaults to `30m`, which is currently the only supported value. See the
+        #   [prompt caching guide](https://developers.openai.com/api/docs/guides/prompt-caching)
+        #   for current details.
+        # @param prompt_cache_retention
+        #   How long to retain a prompt cache entry created by this request.
+        # @param service_tier
+        #   Specifies the processing type used for serving the request. - If set to 'auto',
+        #   then the request will be processed with the service tier configured in the
+        #   Project settings. Unless otherwise configured, the Project will use 'default'. -
+        #   If set to 'default', then the request will be processed with the standard
+        #   pricing and performance for the selected model. - If set to
+        #   '[flex](https://developers.openai.com/api/docs/guides/flex-processing)', then
+        #   the request will be processed with the Flex Processing service tier. - To opt-in
+        #   to [Fast mode](https://developers.openai.com/api/docs/guides/fast-mode) at the
+        #   request level, include the `service_tier=fast` or `service_tier=priority`
+        #   parameter for Responses or Chat Completions. For models with a dedicated Fast
+        #   tier, either value resolves to `service_tier=fast`; for other models, either
+        #   value resolves to `service_tier=priority`. - When not set, the default behavior
+        #   is 'auto'. When the `service_tier` parameter is set, the response body will
+        #   include the `service_tier` value based on the processing mode actually used to
+        #   serve the request. This response value may be different from the value set in
+        #   the parameter.
         def initialize: (
           model: OpenAI::Models::Responses::ResponseCompactParams::model?,
           ?input: OpenAI::Models::Responses::ResponseCompactParams::input?,
@@ -79,6 +169,7 @@ module OpenAI
           | :"gpt-5.1"
           | :"gpt-5.1-2025-11-13"
           | :"gpt-5.1-codex"
+          | :"gpt-5.1-mini"
           | :"gpt-5.1-chat-latest"
           | :"gpt-5"
           | :"gpt-5-mini"
@@ -144,7 +235,6 @@ module OpenAI
           | :"gpt-3.5-turbo-1106"
           | :"gpt-3.5-turbo-0125"
           | :"gpt-3.5-turbo-16k-0613"
-          | :"gpt-5.1-mini"
           | :"o1-pro"
           | :"o1-pro-2025-03-19"
           | :"o3-pro"
@@ -191,6 +281,7 @@ module OpenAI
           GPT_5_1: :"gpt-5.1"
           GPT_5_1_2025_11_13: :"gpt-5.1-2025-11-13"
           GPT_5_1_CODEX: :"gpt-5.1-codex"
+          GPT_5_1_MINI: :"gpt-5.1-mini"
           GPT_5_1_CHAT_LATEST: :"gpt-5.1-chat-latest"
           GPT_5: :"gpt-5"
           GPT_5_MINI: :"gpt-5-mini"
@@ -256,7 +347,6 @@ module OpenAI
           GPT_3_5_TURBO_1106: :"gpt-3.5-turbo-1106"
           GPT_3_5_TURBO_0125: :"gpt-3.5-turbo-0125"
           GPT_3_5_TURBO_16K_0613: :"gpt-3.5-turbo-16k-0613"
-          GPT_5_1_MINI: :"gpt-5.1-mini"
           O1_PRO: :"o1-pro"
           O1_PRO_2025_03_19: :"o1-pro-2025-03-19"
           O3_PRO: :"o3-pro"
@@ -296,18 +386,47 @@ module OpenAI
           }
 
         class PromptCacheOptions < OpenAI::Internal::Type::BaseModel
+          # Controls whether OpenAI automatically creates an implicit cache breakpoint.
+          # Defaults to `implicit`. With `implicit`, OpenAI creates one implicit breakpoint
+          # and writes up to the latest three explicit breakpoints in the request. With
+          # `explicit`, OpenAI does not create an implicit breakpoint and writes up to the
+          # latest four explicit breakpoints. If there are no explicit breakpoints, the
+          # request does not use prompt caching.
           attr_reader mode: OpenAI::Models::Responses::ResponseCompactParams::PromptCacheOptions::mode?
 
+          # Controls whether OpenAI automatically creates an implicit cache breakpoint.
+          # Defaults to `implicit`. With `implicit`, OpenAI creates one implicit breakpoint
+          # and writes up to the latest three explicit breakpoints in the request. With
+          # `explicit`, OpenAI does not create an implicit breakpoint and writes up to the
+          # latest four explicit breakpoints. If there are no explicit breakpoints, the
+          # request does not use prompt caching.
           def mode=: (
             OpenAI::Models::Responses::ResponseCompactParams::PromptCacheOptions::mode
           ) -> OpenAI::Models::Responses::ResponseCompactParams::PromptCacheOptions::mode
 
+          # The minimum lifetime applied to every implicit and explicit cache breakpoint
+          # written by the request. Defaults to `30m`, which is currently the only supported
+          # value. The backend may retain cache entries for longer.
           attr_reader ttl: OpenAI::Models::Responses::ResponseCompactParams::PromptCacheOptions::ttl?
 
+          # The minimum lifetime applied to every implicit and explicit cache breakpoint
+          # written by the request. Defaults to `30m`, which is currently the only supported
+          # value. The backend may retain cache entries for longer.
           def ttl=: (
             OpenAI::Models::Responses::ResponseCompactParams::PromptCacheOptions::ttl
           ) -> OpenAI::Models::Responses::ResponseCompactParams::PromptCacheOptions::ttl
 
+          # @param mode
+          #   Controls whether OpenAI automatically creates an implicit cache breakpoint.
+          #   Defaults to `implicit`. With `implicit`, OpenAI creates one implicit breakpoint
+          #   and writes up to the latest three explicit breakpoints in the request. With
+          #   `explicit`, OpenAI does not create an implicit breakpoint and writes up to the
+          #   latest four explicit breakpoints. If there are no explicit breakpoints, the
+          #   request does not use prompt caching.
+          # @param ttl
+          #   The minimum lifetime applied to every implicit and explicit cache breakpoint
+          #   written by the request. Defaults to `30m`, which is currently the only supported
+          #   value. The backend may retain cache entries for longer.
           def initialize: (
             ?mode: OpenAI::Models::Responses::ResponseCompactParams::PromptCacheOptions::mode,
             ?ttl: OpenAI::Models::Responses::ResponseCompactParams::PromptCacheOptions::ttl

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

@@ -10,14 +10,26 @@ module OpenAI
         }
 
       class ResponseCompactionCompactingEvent < OpenAI::Internal::Type::BaseModel
+        # The ID of the compaction output item.
         attr_accessor item_id: String
 
+        # The index of the compaction output item.
         attr_accessor output_index: Integer
 
+        # The sequence number of the event that was emitted.
         attr_accessor sequence_number: Integer
 
+        # The type of the event, always `response.compaction.compacting`.
         attr_accessor type: :"response.compaction.compacting"
 
+        # @param item_id
+        #   The ID of the compaction output item.
+        # @param output_index
+        #   The index of the compaction output item.
+        # @param sequence_number
+        #   The sequence number of the event that was emitted.
+        # @param type
+        #   The type of the event, always `response.compaction.compacting`.
         def initialize: (
           item_id: String,
           output_index: Integer,

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

@@ -10,16 +10,29 @@ module OpenAI
         }
 
       class ResponseCompactionItem < OpenAI::Internal::Type::BaseModel
+        # The unique ID of the compaction item.
         attr_accessor id: String
 
+        # The encrypted content that was produced by compaction.
         attr_accessor encrypted_content: String
 
+        # The type of the item. Always `compaction`.
         attr_accessor type: :compaction
 
+        # The identifier of the actor that created the item.
         attr_reader created_by: String?
 
+        # The identifier of the actor that created the item.
         def created_by=: (String) -> String
 
+        # @param id
+        #   The unique ID of the compaction item.
+        # @param encrypted_content
+        #   The encrypted content that was produced by compaction.
+        # @param created_by
+        #   The identifier of the actor that created the item.
+        # @param type
+        #   The type of the item. Always `compaction`.
         def initialize: (
           id: String,
           encrypted_content: String,

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

@@ -5,12 +5,21 @@ module OpenAI
         { encrypted_content: String, ?type: :compaction, ?id: String? }
 
       class ResponseCompactionItemParam < OpenAI::Internal::Type::BaseModel
+        # The encrypted content of the compaction summary.
         attr_accessor encrypted_content: String
 
+        # The type of the item. Always `compaction`.
         attr_accessor type: :compaction
 
+        # The ID of the compaction item.
         attr_accessor id: String?
 
+        # @param encrypted_content
+        #   The encrypted content of the compaction summary.
+        # @param id
+        #   The ID of the compaction item.
+        # @param type
+        #   The type of the item. Always `compaction`.
         def initialize: (
           encrypted_content: String,
           ?id: String?,

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

@@ -9,12 +9,21 @@ module OpenAI
         }
 
       class ResponseCompletedEvent < OpenAI::Internal::Type::BaseModel
+        # Properties of the completed response.
         attr_accessor response: OpenAI::Responses::Response
 
+        # The sequence number for this event.
         attr_accessor sequence_number: Integer
 
+        # The type of the event. Always `response.completed`.
         attr_accessor type: :"response.completed"
 
+        # @param response
+        #   Properties of the completed response.
+        # @param sequence_number
+        #   The sequence number for this event.
+        # @param type
+        #   The type of the event. Always `response.completed`.
         def initialize: (
           response: OpenAI::Responses::Response,
           sequence_number: Integer,

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

@@ -13,28 +13,56 @@ module OpenAI
         }
 
       class ResponseComputerToolCall < OpenAI::Internal::Type::BaseModel
+        # The unique ID of the computer call.
         attr_accessor id: String
 
+        # An identifier used when responding to the tool call with output.
         attr_accessor call_id: String
 
+        # The pending safety checks for the computer call.
         attr_accessor pending_safety_checks: ::Array[OpenAI::Responses::ResponseComputerToolCall::PendingSafetyCheck]
 
+        # The status of the item. One of `in_progress`, `completed`, or `incomplete`.
+        # Populated when items are returned via API.
         attr_accessor status: OpenAI::Models::Responses::ResponseComputerToolCall::status
 
+        # The type of the computer call. Always `computer_call`.
         attr_accessor type: OpenAI::Models::Responses::ResponseComputerToolCall::type_
 
+        # A click action.
         attr_reader action: OpenAI::Models::Responses::ResponseComputerToolCall::action?
 
+        # A click action.
         def action=: (
           OpenAI::Models::Responses::ResponseComputerToolCall::action
         ) -> OpenAI::Models::Responses::ResponseComputerToolCall::action
 
+        # Flattened batched actions for `computer_use`. Each action includes an `type`
+        # discriminator and action-specific fields.
         attr_reader actions: OpenAI::Models::Responses::computer_action_list?
 
+        # Flattened batched actions for `computer_use`. Each action includes an `type`
+        # discriminator and action-specific fields.
         def actions=: (
           OpenAI::Models::Responses::computer_action_list
         ) -> OpenAI::Models::Responses::computer_action_list
 
+        # @param id
+        #   The unique ID of the computer call.
+        # @param call_id
+        #   An identifier used when responding to the tool call with output.
+        # @param pending_safety_checks
+        #   The pending safety checks for the computer call.
+        # @param status
+        #   The status of the item. One of `in_progress`, `completed`, or `incomplete`.
+        #   Populated when items are returned via API.
+        # @param type
+        #   The type of the computer call. Always `computer_call`.
+        # @param action
+        #   A click action.
+        # @param actions
+        #   Flattened batched actions for `computer_use`. Each action includes an `type`
+        #   discriminator and action-specific fields.
         def initialize: (
           id: String,
           call_id: String,
@@ -59,12 +87,21 @@ module OpenAI
           { id: String, ?code: String?, ?message: String? }
 
         class PendingSafetyCheck < OpenAI::Internal::Type::BaseModel
+          # The ID of the pending safety check.
           attr_accessor id: String
 
+          # The type of the pending safety check.
           attr_accessor code: String?
 
+          # Details about the pending safety check.
           attr_accessor message: String?
 
+          # @param id
+          #   The ID of the pending safety check.
+          # @param code
+          #   The type of the pending safety check.
+          # @param message
+          #   Details about the pending safety check.
           def initialize: (
             id: String,
             ?code: String?,
@@ -120,16 +157,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::ResponseComputerToolCall::Action::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::ResponseComputerToolCall::Action::Click::button,
               x: Integer,
@@ -170,14 +224,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,
@@ -201,12 +269,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::ResponseComputerToolCall::Action::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::ResponseComputerToolCall::Action::Drag::Path],
               ?keys: ::Array[String]?,
@@ -222,10 +317,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 }
@@ -235,10 +336,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 }
@@ -248,14 +359,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,
@@ -274,8 +399,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 }
@@ -292,18 +422,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,
@@ -326,10 +476,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 }
@@ -338,8 +496,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 }