openai 0.68.0 → 0.69.0

data/rbi/openai/models/responses/tool.rbi

@@ -16,6 +16,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,
@@ -42,6 +43,16 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
+          # The tool invocation context(s).
+          sig do
+            returns(
+              T.nilable(
+                T::Array[OpenAI::Responses::Tool::Mcp::AllowedCaller::OrSymbol]
+              )
+            )
+          end
+          attr_accessor :allowed_callers
+
           # List of allowed tool names or a filter object.
           sig do
             returns(
@@ -147,6 +158,12 @@ module OpenAI
           sig do
             params(
               server_label: String,
+              allowed_callers:
+                T.nilable(
+                  T::Array[
+                    OpenAI::Responses::Tool::Mcp::AllowedCaller::OrSymbol
+                  ]
+                ),
               allowed_tools:
                 T.nilable(
                   T.any(
@@ -174,6 +191,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
@@ -221,6 +240,12 @@ module OpenAI
               {
                 server_label: String,
                 type: Symbol,
+                allowed_callers:
+                  T.nilable(
+                    T::Array[
+                      OpenAI::Responses::Tool::Mcp::AllowedCaller::OrSymbol
+                    ]
+                  ),
                 allowed_tools:
                   T.nilable(
                     T.any(
@@ -249,6 +274,37 @@ module OpenAI
           def to_hash
           end
 
+          module AllowedCaller
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(Symbol, OpenAI::Responses::Tool::Mcp::AllowedCaller)
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            DIRECT =
+              T.let(
+                :direct,
+                OpenAI::Responses::Tool::Mcp::AllowedCaller::TaggedSymbol
+              )
+            PROGRAMMATIC =
+              T.let(
+                :programmatic,
+                OpenAI::Responses::Tool::Mcp::AllowedCaller::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Responses::Tool::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
@@ -675,6 +731,18 @@ module OpenAI
           sig { returns(Symbol) }
           attr_accessor :type
 
+          # The tool invocation context(s).
+          sig do
+            returns(
+              T.nilable(
+                T::Array[
+                  OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller::OrSymbol
+                ]
+              )
+            )
+          end
+          attr_accessor :allowed_callers
+
           # A tool that runs Python code to help generate a response to a prompt.
           sig do
             params(
@@ -683,6 +751,12 @@ module OpenAI
                   String,
                   OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto::OrHash
                 ),
+              allowed_callers:
+                T.nilable(
+                  T::Array[
+                    OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller::OrSymbol
+                  ]
+                ),
               type: Symbol
             ).returns(T.attached_class)
           end
@@ -691,6 +765,8 @@ module OpenAI
             # specifies uploaded file IDs to make available to your code, along with an
             # optional `memory_limit` setting.
             container:,
+            # The tool invocation context(s).
+            allowed_callers: nil,
             # The type of the code interpreter tool. Always `code_interpreter`.
             type: :code_interpreter
           )
@@ -704,7 +780,13 @@ module OpenAI
                     String,
                     OpenAI::Responses::Tool::CodeInterpreter::Container::CodeInterpreterToolAuto
                   ),
-                type: Symbol
+                type: Symbol,
+                allowed_callers:
+                  T.nilable(
+                    T::Array[
+                      OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller::OrSymbol
+                    ]
+                  )
               }
             )
           end
@@ -907,6 +989,65 @@ module OpenAI
             def self.variants
             end
           end
+
+          module AllowedCaller
+            extend OpenAI::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            DIRECT =
+              T.let(
+                :direct,
+                OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller::TaggedSymbol
+              )
+            PROGRAMMATIC =
+              T.let(
+                :programmatic,
+                OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  OpenAI::Responses::Tool::CodeInterpreter::AllowedCaller::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+
+        class ProgrammaticToolCalling < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Responses::Tool::ProgrammaticToolCalling,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The type of the tool. Always `programmatic_tool_calling`.
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig { params(type: Symbol).returns(T.attached_class) }
+          def self.new(
+            # The type of the tool. Always `programmatic_tool_calling`.
+            type: :programmatic_tool_calling
+          )
+          end
+
+          sig { override.returns({ type: Symbol }) }
+          def to_hash
+          end
         end
 
         class ImageGeneration < OpenAI::Internal::Type::BaseModel

data/rbi/openai/models/webhooks/safety_identifier_blocked_webhook_event.rbi

@@ -0,0 +1,209 @@
+# typed: strong
+
+module OpenAI
+  module Models
+    module Webhooks
+      class SafetyIdentifierBlockedWebhookEvent < OpenAI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent,
+              OpenAI::Internal::AnyHash
+            )
+          end
+
+        # The unique ID of the event.
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The Unix timestamp (in seconds) of when the request was blocked.
+        sig { returns(Integer) }
+        attr_accessor :created_at
+
+        # Event data payload.
+        sig do
+          returns(OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent::Data)
+        end
+        attr_reader :data
+
+        sig do
+          params(
+            data:
+              OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent::Data::OrHash
+          ).void
+        end
+        attr_writer :data
+
+        # The type of the event. Always `safety_identifier.blocked`.
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # The object of the event. Always `event`.
+        sig do
+          returns(
+            T.nilable(
+              OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent::Object::TaggedSymbol
+            )
+          )
+        end
+        attr_reader :object
+
+        sig do
+          params(
+            object:
+              OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent::Object::OrSymbol
+          ).void
+        end
+        attr_writer :object
+
+        # Sent when a request associated with a safety identifier has been blocked.
+        sig do
+          params(
+            id: String,
+            created_at: Integer,
+            data:
+              OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent::Data::OrHash,
+            object:
+              OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent::Object::OrSymbol,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The unique ID of the event.
+          id:,
+          # The Unix timestamp (in seconds) of when the request was blocked.
+          created_at:,
+          # Event data payload.
+          data:,
+          # The object of the event. Always `event`.
+          object: nil,
+          # The type of the event. Always `safety_identifier.blocked`.
+          type: :"safety_identifier.blocked"
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              created_at: Integer,
+              data: OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent::Data,
+              type: Symbol,
+              object:
+                OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent::Object::TaggedSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Data < OpenAI::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent::Data,
+                OpenAI::Internal::AnyHash
+              )
+            end
+
+          # The safety category that triggered the block, such as `bio` or `cyber`.
+          sig { returns(String) }
+          attr_accessor :safety_category
+
+          # The stable safety identifier associated with the blocked request.
+          sig { returns(String) }
+          attr_accessor :safety_identifier
+
+          # The model used for the blocked request, if available.
+          sig { returns(T.nilable(String)) }
+          attr_reader :model
+
+          sig { params(model: String).void }
+          attr_writer :model
+
+          # The project associated with the blocked request, if available.
+          sig { returns(T.nilable(String)) }
+          attr_reader :project_id
+
+          sig { params(project_id: String).void }
+          attr_writer :project_id
+
+          # The OpenAI request ID for the blocked request, if available.
+          sig { returns(T.nilable(String)) }
+          attr_reader :request_id
+
+          sig { params(request_id: String).void }
+          attr_writer :request_id
+
+          # Event data payload.
+          sig do
+            params(
+              safety_category: String,
+              safety_identifier: String,
+              model: String,
+              project_id: String,
+              request_id: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # The safety category that triggered the block, such as `bio` or `cyber`.
+            safety_category:,
+            # The stable safety identifier associated with the blocked request.
+            safety_identifier:,
+            # The model used for the blocked request, if available.
+            model: nil,
+            # The project associated with the blocked request, if available.
+            project_id: nil,
+            # The OpenAI request ID for the blocked request, if available.
+            request_id: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                safety_category: String,
+                safety_identifier: String,
+                model: String,
+                project_id: String,
+                request_id: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        # The object of the event. Always `event`.
+        module Object
+          extend OpenAI::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent::Object
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          EVENT =
+            T.let(
+              :event,
+              OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent::Object::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent::Object::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/openai/models/webhooks/unwrap_webhook_event.rbi

@@ -24,7 +24,8 @@ module OpenAI
               OpenAI::Webhooks::ResponseCancelledWebhookEvent,
               OpenAI::Webhooks::ResponseCompletedWebhookEvent,
               OpenAI::Webhooks::ResponseFailedWebhookEvent,
-              OpenAI::Webhooks::ResponseIncompleteWebhookEvent
+              OpenAI::Webhooks::ResponseIncompleteWebhookEvent,
+              OpenAI::Webhooks::SafetyIdentifierBlockedWebhookEvent
             )
           end
 

data/rbi/openai/resources/beta/assistants.rbi

@@ -61,19 +61,12 @@ module OpenAI
           metadata: nil,
           # The name of the assistant. The maximum length is 256 characters.
           name: 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.
           reasoning_effort: nil,
           # Specifies the format that the model must output. Compatible with
           # [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),
@@ -196,19 +189,12 @@ module OpenAI
           model: nil,
           # The name of the assistant. The maximum length is 256 characters.
           name: 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.
           reasoning_effort: nil,
           # Specifies the format that the model must output. Compatible with
           # [GPT-4o](https://platform.openai.com/docs/models#gpt-4o),

data/rbi/openai/resources/beta/responses/input_items.rbi

@@ -0,0 +1,58 @@
+# typed: strong
+
+module OpenAI
+  module Resources
+    class Beta
+      class Responses
+        class InputItems
+          # Returns a list of input items for a given response.
+          sig do
+            params(
+              response_id: String,
+              after: String,
+              include: T::Array[OpenAI::Beta::BetaResponseIncludable::OrSymbol],
+              limit: Integer,
+              order:
+                OpenAI::Beta::Responses::InputItemListParams::Order::OrSymbol,
+              betas:
+                T::Array[
+                  OpenAI::Beta::Responses::InputItemListParams::Beta::OrSymbol
+                ],
+              request_options: OpenAI::RequestOptions::OrHash
+            ).returns(
+              OpenAI::Internal::CursorPage[
+                OpenAI::Beta::BetaResponseItem::Variants
+              ]
+            )
+          end
+          def list(
+            # Path param: The ID of the response to retrieve input items for.
+            response_id,
+            # Query param: An item ID to list items after, used in pagination.
+            after: nil,
+            # Query param: Additional fields to include in the response. See the `include`
+            # parameter for Response creation above for more information.
+            include: nil,
+            # Query param: A limit on the number of objects to be returned. Limit can range
+            # between 1 and 100, and the default is 20.
+            limit: nil,
+            # Query param: The order to return the input items in. Default is `desc`.
+            #
+            # - `asc`: Return the input items in ascending order.
+            # - `desc`: Return the input items in descending order.
+            order: nil,
+            # Header param: Optional beta features to enable for this request.
+            betas: nil,
+            request_options: {}
+          )
+          end
+
+          # @api private
+          sig { params(client: OpenAI::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end