openai 0.68.0 → 0.69.0

data/rbi/openai/models/realtime/realtime_response_create_mcp_tool.rbi

@@ -20,6 +20,18 @@ module OpenAI
         sig { returns(Symbol) }
         attr_accessor :type
 
+        # The tool invocation context(s).
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                OpenAI::Realtime::RealtimeResponseCreateMcpTool::AllowedCaller::OrSymbol
+              ]
+            )
+          )
+        end
+        attr_accessor :allowed_callers
+
         # List of allowed tool names or a filter object.
         sig do
           returns(
@@ -128,6 +140,12 @@ module OpenAI
         sig do
           params(
             server_label: String,
+            allowed_callers:
+              T.nilable(
+                T::Array[
+                  OpenAI::Realtime::RealtimeResponseCreateMcpTool::AllowedCaller::OrSymbol
+                ]
+              ),
             allowed_tools:
               T.nilable(
                 T.any(
@@ -156,6 +174,8 @@ module OpenAI
         def self.new(
           # A label for this MCP server, used to identify it in tool calls.
           server_label:,
+          # The tool invocation context(s).
+          allowed_callers: nil,
           # List of allowed tool names or a filter object.
           allowed_tools: nil,
           # An OAuth access token that can be used with a remote MCP server, either with a
@@ -203,6 +223,12 @@ module OpenAI
             {
               server_label: String,
               type: Symbol,
+              allowed_callers:
+                T.nilable(
+                  T::Array[
+                    OpenAI::Realtime::RealtimeResponseCreateMcpTool::AllowedCaller::OrSymbol
+                  ]
+                ),
               allowed_tools:
                 T.nilable(
                   T.any(
@@ -231,6 +257,40 @@ module OpenAI
         def to_hash
         end
 
+        module AllowedCaller
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                OpenAI::Realtime::RealtimeResponseCreateMcpTool::AllowedCaller
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          DIRECT =
+            T.let(
+              :direct,
+              OpenAI::Realtime::RealtimeResponseCreateMcpTool::AllowedCaller::TaggedSymbol
+            )
+          PROGRAMMATIC =
+            T.let(
+              :programmatic,
+              OpenAI::Realtime::RealtimeResponseCreateMcpTool::AllowedCaller::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Realtime::RealtimeResponseCreateMcpTool::AllowedCaller::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
         # List of allowed tool names or a filter object.
         module AllowedTools
           extend OpenAI::Internal::Type::Union

data/rbi/openai/models/realtime/realtime_session_create_request.rbi

@@ -543,6 +543,16 @@ module OpenAI
               :"gpt-realtime-2",
               OpenAI::Realtime::RealtimeSessionCreateRequest::Model::TaggedSymbol
             )
+          GPT_REALTIME_2_1 =
+            T.let(
+              :"gpt-realtime-2.1",
+              OpenAI::Realtime::RealtimeSessionCreateRequest::Model::TaggedSymbol
+            )
+          GPT_REALTIME_2_1_MINI =
+            T.let(
+              :"gpt-realtime-2.1-mini",
+              OpenAI::Realtime::RealtimeSessionCreateRequest::Model::TaggedSymbol
+            )
           GPT_REALTIME_2025_08_28 =
             T.let(
               :"gpt-realtime-2025-08-28",

data/rbi/openai/models/realtime/realtime_session_create_response.rbi

@@ -1349,6 +1349,16 @@ module OpenAI
               :"gpt-realtime-2",
               OpenAI::Realtime::RealtimeSessionCreateResponse::Model::TaggedSymbol
             )
+          GPT_REALTIME_2_1 =
+            T.let(
+              :"gpt-realtime-2.1",
+              OpenAI::Realtime::RealtimeSessionCreateResponse::Model::TaggedSymbol
+            )
+          GPT_REALTIME_2_1_MINI =
+            T.let(
+              :"gpt-realtime-2.1-mini",
+              OpenAI::Realtime::RealtimeSessionCreateResponse::Model::TaggedSymbol
+            )
           GPT_REALTIME_2025_08_28 =
             T.let(
               :"gpt-realtime-2025-08-28",
@@ -1511,6 +1521,18 @@ module OpenAI
             sig { returns(Symbol) }
             attr_accessor :type
 
+            # The tool invocation context(s).
+            sig do
+              returns(
+                T.nilable(
+                  T::Array[
+                    OpenAI::Realtime::RealtimeSessionCreateResponse::Tool::McpTool::AllowedCaller::TaggedSymbol
+                  ]
+                )
+              )
+            end
+            attr_accessor :allowed_callers
+
             # List of allowed tool names or a filter object.
             sig do
               returns(
@@ -1613,6 +1635,12 @@ module OpenAI
             sig do
               params(
                 server_label: String,
+                allowed_callers:
+                  T.nilable(
+                    T::Array[
+                      OpenAI::Realtime::RealtimeSessionCreateResponse::Tool::McpTool::AllowedCaller::OrSymbol
+                    ]
+                  ),
                 allowed_tools:
                   T.nilable(
                     T.any(
@@ -1641,6 +1669,8 @@ module OpenAI
             def self.new(
               # A label for this MCP server, used to identify it in tool calls.
               server_label:,
+              # The tool invocation context(s).
+              allowed_callers: nil,
               # List of allowed tool names or a filter object.
               allowed_tools: nil,
               # An OAuth access token that can be used with a remote MCP server, either with a
@@ -1688,6 +1718,12 @@ module OpenAI
                 {
                   server_label: String,
                   type: Symbol,
+                  allowed_callers:
+                    T.nilable(
+                      T::Array[
+                        OpenAI::Realtime::RealtimeSessionCreateResponse::Tool::McpTool::AllowedCaller::TaggedSymbol
+                      ]
+                    ),
                   allowed_tools:
                     T.nilable(
                       OpenAI::Realtime::RealtimeSessionCreateResponse::Tool::McpTool::AllowedTools::Variants
@@ -1710,6 +1746,40 @@ module OpenAI
             def to_hash
             end
 
+            module AllowedCaller
+              extend OpenAI::Internal::Type::Enum
+
+              TaggedSymbol =
+                T.type_alias do
+                  T.all(
+                    Symbol,
+                    OpenAI::Realtime::RealtimeSessionCreateResponse::Tool::McpTool::AllowedCaller
+                  )
+                end
+              OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+              DIRECT =
+                T.let(
+                  :direct,
+                  OpenAI::Realtime::RealtimeSessionCreateResponse::Tool::McpTool::AllowedCaller::TaggedSymbol
+                )
+              PROGRAMMATIC =
+                T.let(
+                  :programmatic,
+                  OpenAI::Realtime::RealtimeSessionCreateResponse::Tool::McpTool::AllowedCaller::TaggedSymbol
+                )
+
+              sig do
+                override.returns(
+                  T::Array[
+                    OpenAI::Realtime::RealtimeSessionCreateResponse::Tool::McpTool::AllowedCaller::TaggedSymbol
+                  ]
+                )
+              end
+              def self.values
+              end
+            end
+
             # List of allowed tool names or a filter object.
             module AllowedTools
               extend OpenAI::Internal::Type::Union

data/rbi/openai/models/realtime/realtime_tools_config_union.rbi

@@ -34,6 +34,18 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
+          # The tool invocation context(s).
+          sig do
+            returns(
+              T.nilable(
+                T::Array[
+                  OpenAI::Realtime::RealtimeToolsConfigUnion::Mcp::AllowedCaller::OrSymbol
+                ]
+              )
+            )
+          end
+          attr_accessor :allowed_callers
+
           # List of allowed tool names or a filter object.
           sig do
             returns(
@@ -142,6 +154,12 @@ module OpenAI
           sig do
             params(
               server_label: String,
+              allowed_callers:
+                T.nilable(
+                  T::Array[
+                    OpenAI::Realtime::RealtimeToolsConfigUnion::Mcp::AllowedCaller::OrSymbol
+                  ]
+                ),
               allowed_tools:
                 T.nilable(
                   T.any(
@@ -170,6 +188,8 @@ module OpenAI
           def self.new(
             # A label for this MCP server, used to identify it in tool calls.
             server_label:,
+            # The tool invocation context(s).
+            allowed_callers: nil,
             # List of allowed tool names or a filter object.
             allowed_tools: nil,
             # An OAuth access token that can be used with a remote MCP server, either with a
@@ -217,6 +237,12 @@ module OpenAI
               {
                 server_label: String,
                 type: Symbol,
+                allowed_callers:
+                  T.nilable(
+                    T::Array[
+                      OpenAI::Realtime::RealtimeToolsConfigUnion::Mcp::AllowedCaller::OrSymbol
+                    ]
+                  ),
                 allowed_tools:
                   T.nilable(
                     T.any(
@@ -245,6 +271,40 @@ module OpenAI
           def to_hash
           end
 
+          module AllowedCaller
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  OpenAI::Realtime::RealtimeToolsConfigUnion::Mcp::AllowedCaller
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            DIRECT =
+              T.let(
+                :direct,
+                OpenAI::Realtime::RealtimeToolsConfigUnion::Mcp::AllowedCaller::TaggedSymbol
+              )
+            PROGRAMMATIC =
+              T.let(
+                :programmatic,
+                OpenAI::Realtime::RealtimeToolsConfigUnion::Mcp::AllowedCaller::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Realtime::RealtimeToolsConfigUnion::Mcp::AllowedCaller::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+
           # List of allowed tool names or a filter object.
           module AllowedTools
             extend OpenAI::Internal::Type::Union

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