openai 0.67.0 → 0.69.0

data/rbi/openai/models/reasoning.rbi

@@ -12,19 +12,12 @@ module OpenAI
       sig { returns(T.nilable(OpenAI::Reasoning::Context::OrSymbol)) }
       attr_accessor :context
 
-      # Constrains effort on reasoning for
-      # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-      # supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
-      # Reducing reasoning effort can result in faster responses and fewer tokens used
-      # on reasoning in a response.
-      #
-      # - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
-      #   reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
-      #   calls are supported for all reasoning values in gpt-5.1.
-      # - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
-      #   support `none`.
-      # - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
-      # - `xhigh` is supported for all models after `gpt-5.1-codex-max`.
+      # Constrains effort on reasoning for reasoning models. Currently supported values
+      # are `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. Reducing
+      # reasoning effort can result in faster responses and fewer tokens used on
+      # reasoning in a response. Not all reasoning models support every value. See the
+      # [reasoning guide](https://platform.openai.com/docs/guides/reasoning) for
+      # model-specific support.
       sig { returns(T.nilable(OpenAI::ReasoningEffort::OrSymbol)) }
       attr_accessor :effort
 
@@ -36,6 +29,19 @@ module OpenAI
       sig { returns(T.nilable(OpenAI::Reasoning::GenerateSummary::OrSymbol)) }
       attr_accessor :generate_summary
 
+      # Controls the reasoning execution mode for the request.
+      #
+      # When returned on a response, this is the effective execution mode.
+      sig do
+        returns(T.nilable(T.any(String, OpenAI::Reasoning::Mode::OrSymbol)))
+      end
+      attr_reader :mode
+
+      sig do
+        params(mode: T.any(String, OpenAI::Reasoning::Mode::OrSymbol)).void
+      end
+      attr_writer :mode
+
       # A summary of the reasoning performed by the model. This can be useful for
       # debugging and understanding the model's reasoning process. One of `auto`,
       # `concise`, or `detailed`.
@@ -55,6 +61,7 @@ module OpenAI
           effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol),
           generate_summary:
             T.nilable(OpenAI::Reasoning::GenerateSummary::OrSymbol),
+          mode: T.any(String, OpenAI::Reasoning::Mode::OrSymbol),
           summary: T.nilable(OpenAI::Reasoning::Summary::OrSymbol)
         ).returns(T.attached_class)
       end
@@ -63,19 +70,12 @@ module OpenAI
         # When returned on a response, this is the effective reasoning context mode used
         # for the response.
         context: nil,
-        # Constrains effort on reasoning for
-        # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-        # supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
-        # Reducing reasoning effort can result in faster responses and fewer tokens used
-        # on reasoning in a response.
-        #
-        # - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
-        #   reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
-        #   calls are supported for all reasoning values in gpt-5.1.
-        # - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
-        #   support `none`.
-        # - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
-        # - `xhigh` is supported for all models after `gpt-5.1-codex-max`.
+        # Constrains effort on reasoning for reasoning models. Currently supported values
+        # are `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. Reducing
+        # reasoning effort can result in faster responses and fewer tokens used on
+        # reasoning in a response. Not all reasoning models support every value. See the
+        # [reasoning guide](https://platform.openai.com/docs/guides/reasoning) for
+        # model-specific support.
         effort: nil,
         # **Deprecated:** use `summary` instead.
         #
@@ -83,6 +83,10 @@ module OpenAI
         # debugging and understanding the model's reasoning process. One of `auto`,
         # `concise`, or `detailed`.
         generate_summary: nil,
+        # Controls the reasoning execution mode for the request.
+        #
+        # When returned on a response, this is the effective execution mode.
+        mode: nil,
         # A summary of the reasoning performed by the model. This can be useful for
         # debugging and understanding the model's reasoning process. One of `auto`,
         # `concise`, or `detailed`.
@@ -100,6 +104,7 @@ module OpenAI
             effort: T.nilable(OpenAI::ReasoningEffort::OrSymbol),
             generate_summary:
               T.nilable(OpenAI::Reasoning::GenerateSummary::OrSymbol),
+            mode: T.any(String, OpenAI::Reasoning::Mode::OrSymbol),
             summary: T.nilable(OpenAI::Reasoning::Summary::OrSymbol)
           }
         )
@@ -156,6 +161,26 @@ module OpenAI
         end
       end
 
+      # Controls the reasoning execution mode for the request.
+      #
+      # When returned on a response, this is the effective execution mode.
+      module Mode
+        extend OpenAI::Internal::Type::Union
+
+        Variants =
+          T.type_alias { T.any(String, OpenAI::Reasoning::Mode::TaggedSymbol) }
+
+        sig { override.returns(T::Array[OpenAI::Reasoning::Mode::Variants]) }
+        def self.variants
+        end
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, OpenAI::Reasoning::Mode) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        STANDARD = T.let(:standard, OpenAI::Reasoning::Mode::TaggedSymbol)
+        PRO = T.let(:pro, OpenAI::Reasoning::Mode::TaggedSymbol)
+      end
+
       # A summary of the reasoning performed by the model. This can be useful for
       # debugging and understanding the model's reasoning process. One of `auto`,
       # `concise`, or `detailed`.

data/rbi/openai/models/reasoning_effort.rbi

@@ -2,19 +2,12 @@
 
 module OpenAI
   module Models
-    # Constrains effort on reasoning for
-    # [reasoning models](https://platform.openai.com/docs/guides/reasoning). Currently
-    # supported values are `none`, `minimal`, `low`, `medium`, `high`, and `xhigh`.
-    # Reducing reasoning effort can result in faster responses and fewer tokens used
-    # on reasoning in a response.
-    #
-    # - `gpt-5.1` defaults to `none`, which does not perform reasoning. The supported
-    #   reasoning values for `gpt-5.1` are `none`, `low`, `medium`, and `high`. Tool
-    #   calls are supported for all reasoning values in gpt-5.1.
-    # - All models before `gpt-5.1` default to `medium` reasoning effort, and do not
-    #   support `none`.
-    # - The `gpt-5-pro` model defaults to (and only supports) `high` reasoning effort.
-    # - `xhigh` is supported for all models after `gpt-5.1-codex-max`.
+    # Constrains effort on reasoning for reasoning models. Currently supported values
+    # are `none`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`. Reducing
+    # reasoning effort can result in faster responses and fewer tokens used on
+    # reasoning in a response. Not all reasoning models support every value. See the
+    # [reasoning guide](https://platform.openai.com/docs/guides/reasoning) for
+    # model-specific support.
     module ReasoningEffort
       extend OpenAI::Internal::Type::Enum
 
@@ -27,6 +20,7 @@ module OpenAI
       MEDIUM = T.let(:medium, OpenAI::ReasoningEffort::TaggedSymbol)
       HIGH = T.let(:high, OpenAI::ReasoningEffort::TaggedSymbol)
       XHIGH = T.let(:xhigh, OpenAI::ReasoningEffort::TaggedSymbol)
+      MAX = T.let(:max, OpenAI::ReasoningEffort::TaggedSymbol)
 
       sig { override.returns(T::Array[OpenAI::ReasoningEffort::TaggedSymbol]) }
       def self.values

data/rbi/openai/models/responses/apply_patch_tool.rbi

@@ -13,17 +13,84 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # The tool invocation context(s).
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                OpenAI::Responses::ApplyPatchTool::AllowedCaller::OrSymbol
+              ]
+            )
+          )
+        end
+        attr_accessor :allowed_callers
+
         # Allows the assistant to create, delete, or update files using unified diffs.
-        sig { params(type: Symbol).returns(T.attached_class) }
+        sig do
+          params(
+            allowed_callers:
+              T.nilable(
+                T::Array[
+                  OpenAI::Responses::ApplyPatchTool::AllowedCaller::OrSymbol
+                ]
+              ),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
         def self.new(
+          # The tool invocation context(s).
+          allowed_callers: nil,
           # The type of the tool. Always `apply_patch`.
           type: :apply_patch
         )
         end
 
-        sig { override.returns({ type: Symbol }) }
+        sig do
+          override.returns(
+            {
+              type: Symbol,
+              allowed_callers:
+                T.nilable(
+                  T::Array[
+                    OpenAI::Responses::ApplyPatchTool::AllowedCaller::OrSymbol
+                  ]
+                )
+            }
+          )
+        end
         def to_hash
         end
+
+        module AllowedCaller
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, OpenAI::Responses::ApplyPatchTool::AllowedCaller)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          DIRECT =
+            T.let(
+              :direct,
+              OpenAI::Responses::ApplyPatchTool::AllowedCaller::TaggedSymbol
+            )
+          PROGRAMMATIC =
+            T.let(
+              :programmatic,
+              OpenAI::Responses::ApplyPatchTool::AllowedCaller::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Responses::ApplyPatchTool::AllowedCaller::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
       end
     end
   end

data/rbi/openai/models/responses/compacted_response.rbi

@@ -54,6 +54,8 @@ module OpenAI
                   OpenAI::Responses::ResponseComputerToolCall::OrHash,
                   OpenAI::Responses::ResponseComputerToolCallOutputItem::OrHash,
                   OpenAI::Responses::ResponseReasoningItem::OrHash,
+                  OpenAI::Responses::ResponseOutputItem::Program::OrHash,
+                  OpenAI::Responses::ResponseOutputItem::ProgramOutput::OrHash,
                   OpenAI::Responses::ResponseToolSearchCall::OrHash,
                   OpenAI::Responses::ResponseToolSearchOutputItem::OrHash,
                   OpenAI::Responses::ResponseOutputItem::AdditionalTools::OrHash,

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

@@ -17,6 +17,16 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # The tool invocation context(s).
+        sig do
+          returns(
+            T.nilable(
+              T::Array[OpenAI::Responses::CustomTool::AllowedCaller::OrSymbol]
+            )
+          )
+        end
+        attr_accessor :allowed_callers
+
         # Whether this tool should be deferred and discovered via tool search.
         sig { returns(T.nilable(T::Boolean)) }
         attr_reader :defer_loading
@@ -60,6 +70,10 @@ module OpenAI
         sig do
           params(
             name: String,
+            allowed_callers:
+              T.nilable(
+                T::Array[OpenAI::Responses::CustomTool::AllowedCaller::OrSymbol]
+              ),
             defer_loading: T::Boolean,
             description: String,
             format_:
@@ -73,6 +87,8 @@ module OpenAI
         def self.new(
           # The name of the custom tool, used to identify it in tool calls.
           name:,
+          # The tool invocation context(s).
+          allowed_callers: nil,
           # 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.
@@ -89,6 +105,12 @@ module OpenAI
             {
               name: String,
               type: Symbol,
+              allowed_callers:
+                T.nilable(
+                  T::Array[
+                    OpenAI::Responses::CustomTool::AllowedCaller::OrSymbol
+                  ]
+                ),
               defer_loading: T::Boolean,
               description: String,
               format_:
@@ -101,6 +123,37 @@ module OpenAI
         end
         def to_hash
         end
+
+        module AllowedCaller
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, OpenAI::Responses::CustomTool::AllowedCaller)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          DIRECT =
+            T.let(
+              :direct,
+              OpenAI::Responses::CustomTool::AllowedCaller::TaggedSymbol
+            )
+          PROGRAMMATIC =
+            T.let(
+              :programmatic,
+              OpenAI::Responses::CustomTool::AllowedCaller::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Responses::CustomTool::AllowedCaller::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
       end
     end
   end

data/rbi/openai/models/responses/function_shell_tool.rbi

@@ -16,6 +16,18 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # The tool invocation context(s).
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                OpenAI::Responses::FunctionShellTool::AllowedCaller::OrSymbol
+              ]
+            )
+          )
+        end
+        attr_accessor :allowed_callers
+
         sig do
           returns(
             T.nilable(
@@ -32,6 +44,12 @@ module OpenAI
         # A tool that allows the model to execute shell commands.
         sig do
           params(
+            allowed_callers:
+              T.nilable(
+                T::Array[
+                  OpenAI::Responses::FunctionShellTool::AllowedCaller::OrSymbol
+                ]
+              ),
             environment:
               T.nilable(
                 T.any(
@@ -44,6 +62,8 @@ module OpenAI
           ).returns(T.attached_class)
         end
         def self.new(
+          # The tool invocation context(s).
+          allowed_callers: nil,
           environment: nil,
           # The type of the shell tool. Always `shell`.
           type: :shell
@@ -54,6 +74,12 @@ module OpenAI
           override.returns(
             {
               type: Symbol,
+              allowed_callers:
+                T.nilable(
+                  T::Array[
+                    OpenAI::Responses::FunctionShellTool::AllowedCaller::OrSymbol
+                  ]
+                ),
               environment:
                 T.nilable(
                   T.any(
@@ -68,6 +94,37 @@ module OpenAI
         def to_hash
         end
 
+        module AllowedCaller
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, OpenAI::Responses::FunctionShellTool::AllowedCaller)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          DIRECT =
+            T.let(
+              :direct,
+              OpenAI::Responses::FunctionShellTool::AllowedCaller::TaggedSymbol
+            )
+          PROGRAMMATIC =
+            T.let(
+              :programmatic,
+              OpenAI::Responses::FunctionShellTool::AllowedCaller::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Responses::FunctionShellTool::AllowedCaller::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
         module Environment
           extend OpenAI::Internal::Type::Union
 

data/rbi/openai/models/responses/function_tool.rbi

@@ -17,7 +17,7 @@ module OpenAI
         sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
         attr_accessor :parameters
 
-        # Whether to enforce strict parameter validation. Default `true`.
+        # Whether strict parameter validation is enforced for this function tool.
         sig { returns(T.nilable(T::Boolean)) }
         attr_accessor :strict
 
@@ -25,6 +25,16 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # The tool invocation context(s).
+        sig do
+          returns(
+            T.nilable(
+              T::Array[OpenAI::Responses::FunctionTool::AllowedCaller::OrSymbol]
+            )
+          )
+        end
+        attr_accessor :allowed_callers
+
         # Whether this function is deferred and loaded via tool search.
         sig { returns(T.nilable(T::Boolean)) }
         attr_reader :defer_loading
@@ -37,6 +47,11 @@ module OpenAI
         sig { returns(T.nilable(String)) }
         attr_accessor :description
 
+        # A JSON schema object describing the JSON value encoded in string outputs for
+        # this function.
+        sig { returns(T.nilable(T::Hash[Symbol, T.anything])) }
+        attr_accessor :output_schema
+
         # Defines a function in your own code the model can choose to call. Learn more
         # about
         # [function calling](https://platform.openai.com/docs/guides/function-calling).
@@ -45,8 +60,15 @@ module OpenAI
             name: String,
             parameters: T.nilable(T::Hash[Symbol, T.anything]),
             strict: T.nilable(T::Boolean),
+            allowed_callers:
+              T.nilable(
+                T::Array[
+                  OpenAI::Responses::FunctionTool::AllowedCaller::OrSymbol
+                ]
+              ),
             defer_loading: T::Boolean,
             description: T.nilable(String),
+            output_schema: T.nilable(T::Hash[Symbol, T.anything]),
             type: Symbol
           ).returns(T.attached_class)
         end
@@ -55,13 +77,18 @@ module OpenAI
           name:,
           # A JSON schema object describing the parameters of the function.
           parameters:,
-          # Whether to enforce strict parameter validation. Default `true`.
+          # Whether strict parameter validation is enforced for this function tool.
           strict:,
+          # The tool invocation context(s).
+          allowed_callers: nil,
           # Whether this function is deferred and loaded via tool search.
           defer_loading: nil,
           # A description of the function. Used by the model to determine whether or not to
           # call the function.
           description: nil,
+          # A JSON schema object describing the JSON value encoded in string outputs for
+          # this function.
+          output_schema: nil,
           # The type of the function tool. Always `function`.
           type: :function
         )
@@ -74,13 +101,51 @@ module OpenAI
               parameters: T.nilable(T::Hash[Symbol, T.anything]),
               strict: T.nilable(T::Boolean),
               type: Symbol,
+              allowed_callers:
+                T.nilable(
+                  T::Array[
+                    OpenAI::Responses::FunctionTool::AllowedCaller::OrSymbol
+                  ]
+                ),
               defer_loading: T::Boolean,
-              description: T.nilable(String)
+              description: T.nilable(String),
+              output_schema: T.nilable(T::Hash[Symbol, T.anything])
             }
           )
         end
         def to_hash
         end
+
+        module AllowedCaller
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, OpenAI::Responses::FunctionTool::AllowedCaller)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          DIRECT =
+            T.let(
+              :direct,
+              OpenAI::Responses::FunctionTool::AllowedCaller::TaggedSymbol
+            )
+          PROGRAMMATIC =
+            T.let(
+              :programmatic,
+              OpenAI::Responses::FunctionTool::AllowedCaller::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Responses::FunctionTool::AllowedCaller::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
       end
     end
   end

data/rbi/openai/models/responses/input_token_count_params.rbi

@@ -125,6 +125,7 @@ module OpenAI
                 OpenAI::Responses::ToolChoiceFunction,
                 OpenAI::Responses::ToolChoiceMcp,
                 OpenAI::Responses::ToolChoiceCustom,
+                OpenAI::Responses::InputTokenCountParams::ToolChoice::SpecificProgrammaticToolCallingParam,
                 OpenAI::Responses::ToolChoiceApplyPatch,
                 OpenAI::Responses::ToolChoiceShell
               )
@@ -146,6 +147,7 @@ module OpenAI
                   OpenAI::Responses::ComputerUsePreviewTool,
                   OpenAI::Responses::Tool::Mcp,
                   OpenAI::Responses::Tool::CodeInterpreter,
+                  OpenAI::Responses::Tool::ProgrammaticToolCalling,
                   OpenAI::Responses::Tool::ImageGeneration,
                   OpenAI::Responses::Tool::LocalShell,
                   OpenAI::Responses::FunctionShellTool,
@@ -218,6 +220,7 @@ module OpenAI
                   OpenAI::Responses::ToolChoiceFunction::OrHash,
                   OpenAI::Responses::ToolChoiceMcp::OrHash,
                   OpenAI::Responses::ToolChoiceCustom::OrHash,
+                  OpenAI::Responses::InputTokenCountParams::ToolChoice::SpecificProgrammaticToolCallingParam::OrHash,
                   OpenAI::Responses::ToolChoiceApplyPatch::OrHash,
                   OpenAI::Responses::ToolChoiceShell::OrHash
                 )
@@ -232,6 +235,7 @@ module OpenAI
                     OpenAI::Responses::ComputerUsePreviewTool::OrHash,
                     OpenAI::Responses::Tool::Mcp::OrHash,
                     OpenAI::Responses::Tool::CodeInterpreter::OrHash,
+                    OpenAI::Responses::Tool::ProgrammaticToolCalling::OrHash,
                     OpenAI::Responses::Tool::ImageGeneration::OrHash,
                     OpenAI::Responses::Tool::LocalShell::OrHash,
                     OpenAI::Responses::FunctionShellTool::OrHash,
@@ -334,6 +338,7 @@ module OpenAI
                     OpenAI::Responses::ToolChoiceFunction,
                     OpenAI::Responses::ToolChoiceMcp,
                     OpenAI::Responses::ToolChoiceCustom,
+                    OpenAI::Responses::InputTokenCountParams::ToolChoice::SpecificProgrammaticToolCallingParam,
                     OpenAI::Responses::ToolChoiceApplyPatch,
                     OpenAI::Responses::ToolChoiceShell
                   )
@@ -348,6 +353,7 @@ module OpenAI
                       OpenAI::Responses::ComputerUsePreviewTool,
                       OpenAI::Responses::Tool::Mcp,
                       OpenAI::Responses::Tool::CodeInterpreter,
+                      OpenAI::Responses::Tool::ProgrammaticToolCalling,
                       OpenAI::Responses::Tool::ImageGeneration,
                       OpenAI::Responses::Tool::LocalShell,
                       OpenAI::Responses::FunctionShellTool,
@@ -643,11 +649,37 @@ module OpenAI
                 OpenAI::Responses::ToolChoiceFunction,
                 OpenAI::Responses::ToolChoiceMcp,
                 OpenAI::Responses::ToolChoiceCustom,
+                OpenAI::Responses::InputTokenCountParams::ToolChoice::SpecificProgrammaticToolCallingParam,
                 OpenAI::Responses::ToolChoiceApplyPatch,
                 OpenAI::Responses::ToolChoiceShell
               )
             end
 
+          class SpecificProgrammaticToolCallingParam < OpenAI::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  OpenAI::Responses::InputTokenCountParams::ToolChoice::SpecificProgrammaticToolCallingParam,
+                  OpenAI::Internal::AnyHash
+                )
+              end
+
+            # The tool to call. Always `programmatic_tool_calling`.
+            sig { returns(Symbol) }
+            attr_accessor :type
+
+            sig { params(type: Symbol).returns(T.attached_class) }
+            def self.new(
+              # The tool to call. Always `programmatic_tool_calling`.
+              type: :programmatic_tool_calling
+            )
+            end
+
+            sig { override.returns({ type: Symbol }) }
+            def to_hash
+            end
+          end
+
           sig do
             override.returns(
               T::Array[