openai 0.103.0 → 0.105.0

data/lib/openai/helpers/vector_stores/files.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+require_relative "../../resources/vector_stores/files"
+require_relative "../resource_polling"
+
+module OpenAI
+  module Resources
+    class VectorStores
+      class Files
+        # Attach a file to a vector store and wait for processing to finish.
+        #
+        # The returned file may have a `failed` or `cancelled` status; callers should
+        # inspect the status and `last_error`. Polling intervals and the overall timeout
+        # are in seconds. Finite timeouts include authentication and request replay
+        # time and disable transport retries so the deadline remains strict. Set
+        # `timeout` to `nil` to wait indefinitely and retain configured transport retries.
+        #
+        # @overload create_and_poll(vector_store_id, file_id:, attributes: nil, chunking_strategy: nil, poll_interval: nil, timeout: 1800.0, request_options: {})
+        #
+        # @param vector_store_id [String] The ID of the vector store for which to create a File.
+        #
+        # @param file_id [String] A File ID to attach to the vector store.
+        #
+        # @param attributes [Hash{Symbol=>String, Float, Boolean}, nil] Attributes to attach to the vector store file.
+        #
+        # @param chunking_strategy [OpenAI::Models::AutoFileChunkingStrategyParam, OpenAI::Models::StaticFileChunkingStrategyObjectParam] The chunking strategy used to chunk the file.
+        #
+        # @param poll_interval [Integer, Float, nil] How often to retrieve the file. When omitted, the SDK honors the server's
+        #   polling hint and otherwise waits 5 seconds.
+        #
+        # @param timeout [Integer, Float, nil] Maximum total time to poll. Defaults to 30 minutes. Set to `nil` to wait
+        #   indefinitely.
+        #
+        # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @raise [ArgumentError, OpenAI::Errors::PollingError]
+        # @return [OpenAI::Models::VectorStores::VectorStoreFile]
+        def create_and_poll(
+          vector_store_id,
+          file_id:,
+          attributes: nil,
+          chunking_strategy: nil,
+          poll_interval: nil,
+          timeout: OpenAI::Internal::Poller::DEFAULT_TIMEOUT,
+          request_options: {}
+        )
+          OpenAI::Internal::Poller.validate!(poll_interval: poll_interval, timeout: timeout)
+
+          params = {file_id: file_id, request_options: request_options}
+          params[:attributes] = attributes unless attributes.nil?
+          params[:chunking_strategy] = chunking_strategy unless chunking_strategy.nil?
+          file = create(vector_store_id, params)
+          poll(
+            file.id,
+            vector_store_id: vector_store_id,
+            poll_interval: poll_interval,
+            timeout: timeout,
+            request_options: request_options
+          )
+        end
+
+        # Wait for a vector store file to finish processing.
+        #
+        # The returned file may have a `failed` or `cancelled` status; callers should
+        # inspect the status and `last_error`. Polling intervals and the overall timeout
+        # are in seconds. Set `timeout` to `nil` to wait indefinitely.
+        #
+        # @overload poll(file_id, vector_store_id:, poll_interval: nil, timeout: 1800.0, request_options: {})
+        #
+        # @param file_id [String] The ID of the file being retrieved.
+        #
+        # @param vector_store_id [String] The ID of the vector store that the file belongs to.
+        #
+        # @param poll_interval [Integer, Float, nil] How often to retrieve the file. When omitted, the SDK honors the server's
+        #   polling hint and otherwise waits 5 seconds.
+        #
+        # @param timeout [Integer, Float, nil] Maximum total time to poll. Defaults to 30 minutes. Set to `nil` to wait
+        #   indefinitely.
+        #
+        # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
+        #
+        # @raise [ArgumentError, OpenAI::Errors::PollingError]
+        # @return [OpenAI::Models::VectorStores::VectorStoreFile]
+        def poll(
+          file_id,
+          vector_store_id:,
+          poll_interval: nil,
+          timeout: OpenAI::Internal::Poller::DEFAULT_TIMEOUT,
+          request_options: {}
+        )
+          OpenAI::Helpers::ResourcePolling.poll_vector_store_file(
+            self,
+            file_id,
+            vector_store_id: vector_store_id,
+            poll_interval: poll_interval,
+            timeout: timeout,
+            request_options: request_options
+          )
+        end
+
+        # Upload a file and attach it to a vector store.
+        #
+        # Processing continues asynchronously; use {#upload_and_poll} to wait until the
+        # file is ready.
+        #
+        # @overload upload(vector_store_id, file:, attributes: nil, chunking_strategy: nil, request_options: {})
+        #
+        # @param vector_store_id [String] The ID of the vector store to attach the file to.
+        #
+        # @param file [Pathname, StringIO, IO, String, OpenAI::FilePart] The file to upload.
+        #
+        # @param attributes [Hash{Symbol=>String, Float, Boolean}, nil] Attributes to attach to the vector store file.
+        #
+        # @param chunking_strategy [OpenAI::Models::AutoFileChunkingStrategyParam, OpenAI::Models::StaticFileChunkingStrategyObjectParam] The chunking strategy used to chunk the file.
+        #
+        # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil] Applied to the upload and attach
+        #   requests. Idempotency keys are scoped to each operation.
+        #
+        # @return [OpenAI::Models::VectorStores::VectorStoreFile]
+        def upload(
+          vector_store_id,
+          file:,
+          attributes: nil,
+          chunking_strategy: nil,
+          request_options: {}
+        )
+          request_options_scope = OpenAI::Internal::RequestOptionsScope.new(request_options)
+          uploaded = @client.files.create(
+            file: file,
+            purpose: :assistants,
+            request_options: request_options_scope.child("file-upload")
+          )
+          params = {
+            file_id: uploaded.id,
+            request_options: request_options_scope.child("vector-store-file")
+          }
+          params[:attributes] = attributes unless attributes.nil?
+          params[:chunking_strategy] = chunking_strategy unless chunking_strategy.nil?
+          create(vector_store_id, params)
+        end
+
+        # Upload a file, attach it to a vector store, and wait for processing to
+        # finish.
+        #
+        # The returned file may have a `failed` or `cancelled` status; callers should
+        # inspect the status and `last_error`.
+        #
+        # @overload upload_and_poll(vector_store_id, file:, attributes: nil, chunking_strategy: nil, poll_interval: nil, timeout: 1800.0, request_options: {})
+        #
+        # @param vector_store_id [String] The ID of the vector store to attach the file to.
+        #
+        # @param file [Pathname, StringIO, IO, String, OpenAI::FilePart] The file to upload.
+        #
+        # @param attributes [Hash{Symbol=>String, Float, Boolean}, nil] Attributes to attach to the vector store file.
+        #
+        # @param chunking_strategy [OpenAI::Models::AutoFileChunkingStrategyParam, OpenAI::Models::StaticFileChunkingStrategyObjectParam] The chunking strategy used to chunk the file.
+        #
+        # @param poll_interval [Integer, Float, nil] How often to retrieve the file. When omitted, the SDK honors the server's
+        #   polling hint and otherwise waits 5 seconds.
+        #
+        # @param timeout [Integer, Float, nil] Maximum total time to poll. Defaults to 30 minutes. Set to `nil` to wait
+        #   indefinitely.
+        #
+        # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil] Applied to the upload, attach,
+        #   and polling requests. Idempotency keys are scoped to each write.
+        #
+        # @raise [ArgumentError, OpenAI::Errors::PollingError]
+        # @return [OpenAI::Models::VectorStores::VectorStoreFile]
+        def upload_and_poll(
+          vector_store_id,
+          file:,
+          attributes: nil,
+          chunking_strategy: nil,
+          poll_interval: nil,
+          timeout: OpenAI::Internal::Poller::DEFAULT_TIMEOUT,
+          request_options: {}
+        )
+          OpenAI::Internal::Poller.validate!(poll_interval: poll_interval, timeout: timeout)
+
+          attached = upload(
+            vector_store_id,
+            file: file,
+            attributes: attributes,
+            chunking_strategy: chunking_strategy,
+            request_options: request_options
+          )
+          poll(
+            attached.id,
+            vector_store_id: vector_store_id,
+            poll_interval: poll_interval,
+            timeout: timeout,
+            request_options: request_options
+          )
+        end
+      end
+    end
+  end
+end

data/lib/openai/helpers/websocket/client_request.rb

@@ -6,6 +6,34 @@ module OpenAI
     #
     # @api private
     module ClientRequest
+      # @api private
+      def with_websocket_connection_request(request:, websocket_base_url: nil, options: nil, &block)
+        build = lambda do |deadline|
+          build_shared_websocket_connection_request(
+            request: request,
+            websocket_base_url: websocket_base_url,
+            options: options,
+            deadline: deadline,
+            validate: lambda do |_value|
+              if @provider_runtime || x509_identity?(@copy_options.fetch(:workload_identity))
+                raise(
+                  OpenAI::Errors::Error,
+                  "This client authentication provider does not support WebSocket connections."
+                )
+              end
+            end,
+            invalid_base_url_message: "websocket_base_url must be an absolute HTTP or WebSocket URL without credentials, query, or fragment",
+            malformed_base_url_message: "websocket_base_url is not a valid URL",
+            preserve_base_url_cause: false,
+            extra_query_message: "Use query for WebSocket connection query parameters",
+            max_retries_message: "request_options max_retries is not supported for WebSocket connections",
+            timeout_error: -> (url, _cause) { BindingConnectionError.new(url: url) }
+          )
+        end
+
+        with_websocket_connection_retry(error_class: BindingConnectionError, build: build, &block)
+      end
+
       private def with_websocket_connection_retry(error_class:, build:)
         request, deadline = build.call(nil)
         handshake_completed = false
@@ -60,8 +88,7 @@ module OpenAI
       end
 
       private def build_shared_websocket_connection_request(
-        path:,
-        query:,
+        request:,
         websocket_base_url:,
         options:,
         deadline: nil,
@@ -73,6 +100,7 @@ module OpenAI
         max_retries_message:,
         timeout_error:
       )
+        path = request.fetch(:path)
         validate.call(websocket_base_url)
         websocket_uri = parse_shared_websocket_base_url(
           websocket_base_url,
@@ -86,10 +114,7 @@ module OpenAI
           max_retries_message: max_retries_message
         )
 
-        request = build_request(
-          {method: :get, path: path, query: query, security: {bearer_auth: true}},
-          opts
-        )
+        request = build_request(request, opts)
         error_request = websocket_uri ? with_shared_websocket_base_url(request, path:, base_url: websocket_uri) : request
         error_url = shared_websocket_url(error_request.fetch(:url))
 

data/lib/openai/helpers/websocket/connection.rb

@@ -2,6 +2,64 @@
 
 module OpenAI
   module WebSocket
+    # Retire failed sockets and uncertain writes without changing the raw connection contract.
+    #
+    # @api private
+    module GuardedConnection
+      def closed? = @poisoned || @closed || super
+
+      def close(code: 1000, reason: "")
+        @poisoned || @closed ? abort : super
+        @closed = true
+        nil
+      rescue StandardError
+        @poisoned = true
+        raise transport_error, cause: nil
+      end
+
+      # @api private
+      def abort
+        super
+        @closed = true
+        nil
+      rescue StandardError
+        @poisoned = true
+        raise transport_error, cause: nil
+      end
+
+      private def write_text(text)
+        complete = false
+        super
+        complete = true
+        nil
+      rescue StandardError
+        raise transport_error, cause: nil
+      ensure
+        # Also retire a possibly buffered write when cancellation bypasses
+        # StandardError, before another sender or normal cleanup can flush it.
+        @poisoned = true unless complete
+      end
+
+      private def read_raw_message
+        raise connection_error(failed_read_message) if @poisoned
+        return nil if @closed
+        text = super
+        @closed = text.nil?
+        text
+      rescue StandardError
+        @poisoned = true
+        raise transport_error, cause: nil
+      end
+
+      private def socket_closed?
+        super
+      rescue StandardError
+        @poisoned = true
+        raise transport_error, cause: nil
+      end
+
+    end
+
     # Product-neutral socket lifecycle and text I/O.
     #
     # @api private

data/lib/openai/helpers/websocket/connection_manager.rb

@@ -29,11 +29,13 @@ module OpenAI
         abort_after_block:,
         transport_error_factory: nil,
         transport_error_message: "transport must respond to open",
-        reserved_options_error_message: nil
+        reserved_options_error_message: nil,
+        connection_options: {}
       )
         @transport = transport
         @default_transport = default_transport
         @connection_class = connection_class
+        @connection_options = connection_options.dup.freeze
         @request = request
         @block_error_message = block_error_message
         @abort_after_block = abort_after_block
@@ -60,7 +62,7 @@ module OpenAI
               **@transport_options
             ) do |socket|
               mark_handshake_completed.call
-              connection = @connection_class.new(socket: socket, url: request.fetch(:url))
+              connection = @connection_class.new(socket: socket, url: request.fetch(:url), **@connection_options)
               begin
                 yield(connection)
               ensure

data/lib/openai/helpers/websocket/protocol.rb

@@ -15,8 +15,9 @@ module OpenAI
 
       private def event_type(event, message:)
         raise ArgumentError, message unless event.is_a?(Hash)
+        raise ArgumentError, message if event.key?(:type) && event.key?("type")
 
-        type = event[:type]
+        type = event[:type] || event["type"]
         return type if type.is_a?(String) || type.is_a?(Symbol)
 
         raise ArgumentError, message

data/lib/openai/helpers/websocket/resource.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module WebSocket
+    # Connects generated request and event bindings to the SDK-owned runtime.
+    # Existing API helpers retain their more specific connection methods.
+    #
+    # @api private
+    module Resource
+      def connect(
+        *path_arguments,
+        query: {},
+        websocket_base_url: nil,
+        request_options: nil,
+        transport: nil,
+        transport_options: {},
+        &block
+      )
+        request = __websocket_request(*path_arguments, query: query.dup)
+        base_url = websocket_base_url&.to_s&.dup&.freeze
+        error_factory = -> (url:, **options) { BindingConnectionError.new(url: url, **options) }
+        ConnectionManager
+          .new(
+            transport: transport,
+            transport_options: transport_options,
+            default_transport: lambda do
+              AsyncWebSocketTransport.new(
+                product_name: "WebSocket",
+                error_class: BindingConnectionError,
+                error_factory: error_factory
+              )
+            end,
+            connection_class: TypedConnection,
+            connection_options: {client_event: __websocket_client_event, server_event: __websocket_server_event},
+            request: lambda do |&request_block|
+              @client.with_websocket_connection_request(
+                request: request,
+                websocket_base_url: base_url,
+                options: request_options,
+                &request_block
+              )
+            end,
+            block_error_message: "A block is required to open a WebSocket.",
+            abort_after_block: -> (_connection, error) { !error.nil? },
+            transport_error_factory: -> (url:, error:) {
+              status = error.http_status if error.is_a?(OpenAI::Errors::WebSocketConnectionError)
+              BindingConnectionError.new(url: url, http_status: status)
+            }
+          )
+          .open(&block)
+      end
+    end
+  end
+end

data/lib/openai/helpers/websocket/typed_connection.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module WebSocket
+    # Generic event codec for APIs with generated bindings and no specialized helper.
+    #
+    # @api private
+    class TypedConnection < Connection
+      include GuardedConnection
+      include Protocol
+
+      def initialize(socket:, url:, client_event:, server_event:)
+        super(socket: socket, url: url)
+        @client_event = client_event
+        @server_event = server_event
+        variants = client_event.respond_to?(:variants) ? client_event.variants : [client_event]
+        @client_event_types = variants.map do |variant|
+          variant.fields.dig(:type, :type) if variant.respond_to?(:fields)
+        end
+
+        variants = server_event.respond_to?(:variants) ? server_event.variants : [server_event]
+        @server_event_types = variants.filter_map do |variant|
+          type = variant&.fields&.dig(:type, :type)
+          [type, variant] if type
+        end
+      end
+
+      def send_event(event)
+        send_raw(encode_client_event(event))
+      end
+
+      private def encode_client_event(event)
+        event_type(event, message: "Invalid WebSocket client event.") if event.is_a?(Hash)
+        payload = @client_event ? OpenAI::Internal::Type::Converter.dump(@client_event, event) : event
+        type = event_type(payload, message: "Invalid WebSocket client event.")
+        if @client_event && !@client_event_types.any? { _1.nil? || _1 === type.to_sym || _1 === type.to_s }
+          raise ArgumentError, "Invalid WebSocket client event."
+        end
+
+        payload = coerce(@client_event, payload) if @client_event
+        payload = OpenAI::Internal::Type::Converter.dump(@client_event, payload) if @client_event
+        JSON.generate(payload, max_nesting: false)
+      rescue StandardError, SystemStackError
+        raise ArgumentError, "Invalid WebSocket client event.", cause: nil
+      end
+
+      def parse_event(data)
+        parsed = JSON.parse(data, symbolize_names: true, max_nesting: false)
+        type = event_type(parsed, message: "WebSocket server event must be an object with a string type")
+        _, model = @server_event_types.find { |event_type,| event_type === type.to_sym }
+        return parsed unless model
+
+        # Unknown wire fields must not overwrite a known field's Ruby name.
+        model.fields.each do |name, field|
+          raise ArgumentError if name != field.fetch(:api_name) && parsed.key?(name)
+        end
+
+        coerce(@server_event, parsed)
+      rescue StandardError, SystemStackError
+        raise OpenAI::Errors::WebSocketProtocolError, "Invalid WebSocket server event.", cause: nil
+      end
+
+      private def coerce(type, value)
+        state = OpenAI::Internal::Type::Converter.new_coerce_state
+        result = OpenAI::Internal::Type::Converter.coerce(type, value, state: state)
+        if state[:error] || !state.fetch(:exactness).fetch(:no).zero?
+          raise ArgumentError, "Invalid WebSocket event."
+        end
+
+        result
+      end
+
+      private def connection_error(message) = BindingConnectionError.new(url: @url, message: message)
+
+      private def transport_error = connection_error("WebSocket transport failed.")
+
+      private def failed_read_message = "Cannot read from a failed WebSocket."
+    end
+
+    # @api private
+    class BindingConnectionError < OpenAI::Errors::WebSocketConnectionError
+      def initialize(url:, message: nil, http_status: nil, **_options)
+        super(url: url, message: message, http_status: http_status)
+      end
+
+      private def sanitized_error_url(url)
+        url&.dup&.tap do |value|
+          value.userinfo = nil
+          value.query = nil
+          value.fragment = nil
+        end
+      end
+    end
+  end
+end

data/lib/openai/helpers/websocket.rb

@@ -8,3 +8,7 @@ require_relative "websocket/connection_manager"
 require_relative "websocket/protocol"
 require_relative "websocket/async_websocket_transport"
 require_relative "websocket/client_request"
+require_relative "websocket/typed_connection"
+require_relative "websocket/resource"
+
+OpenAI::Client.include(OpenAI::WebSocket::ClientRequest)

data/lib/openai/models/admin/organization/audit_log_list_response.rb

@@ -1549,7 +1549,7 @@ module OpenAI
               # @!attribute provider
               #   The external storage provider configuration.
               #
-              #   @return [OpenAI::Models::Admin::Organization::AwsExternalStorageProvider, OpenAI::Models::Admin::Organization::AzureExternalStorageProvider, OpenAI::Models::Admin::Organization::GcpExternalStorageProvider, nil]
+              #   @return [OpenAI::Models::Admin::Organization::AwsExternalStorageProvider, OpenAI::Models::Admin::Organization::AzureExternalStorageProvider, OpenAI::Models::Admin::Organization::GcpExternalStorageProvider, OpenAI::Models::Admin::Organization::OciExternalStorageProvider, nil]
               optional(
                 :provider,
                 union: -> {
@@ -1563,7 +1563,7 @@ module OpenAI
               #   @param geography [String]
               #     The OpenAI geography derived from the storage region.
               #
-              #   @param provider [OpenAI::Models::Admin::Organization::AwsExternalStorageProvider, OpenAI::Models::Admin::Organization::AzureExternalStorageProvider, OpenAI::Models::Admin::Organization::GcpExternalStorageProvider]
+              #   @param provider [OpenAI::Models::Admin::Organization::AwsExternalStorageProvider, OpenAI::Models::Admin::Organization::AzureExternalStorageProvider, OpenAI::Models::Admin::Organization::GcpExternalStorageProvider, OpenAI::Models::Admin::Organization::OciExternalStorageProvider]
               #     The external storage provider configuration.
 
               # The external storage provider configuration.
@@ -1580,8 +1580,10 @@ module OpenAI
 
                 variant :gcp, -> { OpenAI::Admin::Organization::GcpExternalStorageProvider }
 
+                variant :oci, -> { OpenAI::Admin::Organization::OciExternalStorageProvider }
+
                 # @!method self.variants
-                #   @return [Array(OpenAI::Models::Admin::Organization::AwsExternalStorageProvider, OpenAI::Models::Admin::Organization::AzureExternalStorageProvider, OpenAI::Models::Admin::Organization::GcpExternalStorageProvider)]
+                #   @return [Array(OpenAI::Models::Admin::Organization::AwsExternalStorageProvider, OpenAI::Models::Admin::Organization::AzureExternalStorageProvider, OpenAI::Models::Admin::Organization::GcpExternalStorageProvider, OpenAI::Models::Admin::Organization::OciExternalStorageProvider)]
               end
             end
           end

data/lib/openai/models/admin/organization/external_storage_configuration.rb

@@ -33,7 +33,7 @@ module OpenAI
 
           # @!attribute provider
           #
-          #   @return [OpenAI::Models::Admin::Organization::AwsExternalStorageProvider, OpenAI::Models::Admin::Organization::AzureExternalStorageProvider, OpenAI::Models::Admin::Organization::GcpExternalStorageProvider]
+          #   @return [OpenAI::Models::Admin::Organization::AwsExternalStorageProvider, OpenAI::Models::Admin::Organization::AzureExternalStorageProvider, OpenAI::Models::Admin::Organization::GcpExternalStorageProvider, OpenAI::Models::Admin::Organization::OciExternalStorageProvider]
           required :provider, union: -> { OpenAI::Admin::Organization::ExternalStorageConfiguration::Provider }
 
           # @!attribute status
@@ -46,7 +46,7 @@ module OpenAI
           #   @param created_at [Integer]
           #   @param geography [String]
           #   @param project_id [String]
-          #   @param provider [OpenAI::Models::Admin::Organization::AwsExternalStorageProvider, OpenAI::Models::Admin::Organization::AzureExternalStorageProvider, OpenAI::Models::Admin::Organization::GcpExternalStorageProvider]
+          #   @param provider [OpenAI::Models::Admin::Organization::AwsExternalStorageProvider, OpenAI::Models::Admin::Organization::AzureExternalStorageProvider, OpenAI::Models::Admin::Organization::GcpExternalStorageProvider, OpenAI::Models::Admin::Organization::OciExternalStorageProvider]
           #   @param status [Symbol, OpenAI::Models::Admin::Organization::ExternalStorageConfiguration::Status]
           #   @param object [Symbol, :"organization.external_storage"]
 
@@ -62,8 +62,10 @@ module OpenAI
 
             variant :gcp, -> { OpenAI::Admin::Organization::GcpExternalStorageProvider }
 
+            variant :oci, -> { OpenAI::Admin::Organization::OciExternalStorageProvider }
+
             # @!method self.variants
-            #   @return [Array(OpenAI::Models::Admin::Organization::AwsExternalStorageProvider, OpenAI::Models::Admin::Organization::AzureExternalStorageProvider, OpenAI::Models::Admin::Organization::GcpExternalStorageProvider)]
+            #   @return [Array(OpenAI::Models::Admin::Organization::AwsExternalStorageProvider, OpenAI::Models::Admin::Organization::AzureExternalStorageProvider, OpenAI::Models::Admin::Organization::GcpExternalStorageProvider, OpenAI::Models::Admin::Organization::OciExternalStorageProvider)]
           end
 
           # @see OpenAI::Models::Admin::Organization::ExternalStorageConfiguration#status

data/lib/openai/models/admin/organization/external_storage_create_params.rb

@@ -16,12 +16,12 @@ module OpenAI
 
           # @!attribute provider
           #
-          #   @return [OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Aws, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Azure, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Gcp]
+          #   @return [OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Aws, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Azure, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Gcp, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Oci]
           required :provider, union: -> { OpenAI::Admin::Organization::ExternalStorageCreateParams::Provider }
 
           # @!method initialize(project_id:, provider:, request_options: {})
           #   @param project_id [String]
-          #   @param provider [OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Aws, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Azure, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Gcp]
+          #   @param provider [OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Aws, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Azure, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Gcp, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Oci]
           #   @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}]
 
           module Provider
@@ -35,6 +35,8 @@ module OpenAI
 
             variant :gcp, -> { OpenAI::Admin::Organization::ExternalStorageCreateParams::Provider::Gcp }
 
+            variant :oci, -> { OpenAI::Admin::Organization::ExternalStorageCreateParams::Provider::Oci }
+
             class Aws < OpenAI::Internal::Type::BaseModel
               # @!attribute bucket
               #
@@ -131,8 +133,36 @@ module OpenAI
               #   @param type [Symbol, :gcp]
             end
 
+            class Oci < OpenAI::Internal::Type::BaseModel
+              # @!attribute bucket
+              #
+              #   @return [String]
+              required :bucket, String
+
+              # @!attribute region
+              #
+              #   @return [String]
+              required :region, String
+
+              # @!attribute tenancy_ocid
+              #
+              #   @return [String]
+              required :tenancy_ocid, String
+
+              # @!attribute type
+              #
+              #   @return [Symbol, :oci]
+              required :type, const: :oci
+
+              # @!method initialize(bucket:, region:, tenancy_ocid:, type: :oci)
+              #   @param bucket [String]
+              #   @param region [String]
+              #   @param tenancy_ocid [String]
+              #   @param type [Symbol, :oci]
+            end
+
             # @!method self.variants
-            #   @return [Array(OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Aws, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Azure, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Gcp)]
+            #   @return [Array(OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Aws, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Azure, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Gcp, OpenAI::Models::Admin::Organization::ExternalStorageCreateParams::Provider::Oci)]
           end
         end
       end