openai 0.102.0 → 0.104.0

data/lib/openai/resources/responses.rb

@@ -1,11 +1,30 @@
 # frozen_string_literal: true
 
+require_relative "../helpers/streaming/response_stream_resource"
+require_relative "../helpers/websocket/resource"
 require_relative "../helpers/structured_output/response_parser"
 
 module OpenAI
   module Resources
     # Create and manage model responses.
     class Responses
+      include OpenAI::WebSocket::Resource
+
+      # @api private
+      def __websocket_request(query: {})
+        {method: :get, path: "responses", query: query, security: {bearer_auth: true}}
+      end
+
+      # @api private
+      def __websocket_client_event
+        OpenAI::Models::Responses::ResponsesClientEvent
+      end
+
+      # @api private
+      def __websocket_server_event
+        OpenAI::Models::Responses::ResponsesServerEvent
+      end
+
       # Create and manage model responses.
       # @return [OpenAI::Resources::Responses::InputItems]
       attr_reader :input_items
@@ -168,7 +187,7 @@ module OpenAI
       # @param safety_identifier [String, nil]
       #   A stable identifier used to help detect users of your application that may be
       #   violating OpenAI's usage policies. The IDs should be a string that uniquely
-      #   identifies each user, with a maximum length of 64 characters. We recommend
+      #   identifies each user, with a maximum length of 128 characters. We recommend
       #   hashing their username or email address, in order to avoid sending us any
       #   identifying information.
       #   [Learn more](https://developers.openai.com/api/docs/guides/safety-best-practices#implement-safety-identifiers).
@@ -307,61 +326,6 @@ module OpenAI
         )
       end
 
-      # Creates or resumes a streaming response and parses structured outputs.
-      # @overload stream(access_programs: nil, **params)
-      #   @param access_programs [OpenAI::Models::Responses::ResponseCreateParams::AccessPrograms]
-      #     Domain-specific access programs to use for this request.
-      #   @param params [Hash{Symbol=>Object}] Other response creation or retrieval parameters.
-      def stream(params)
-        parsed, options = OpenAI::Responses::ResponseCreateParams.dump_request(params)
-        starting_after, response_id = parsed.values_at(:starting_after, :response_id)
-
-        if starting_after && !response_id
-          raise ArgumentError, "starting_after can only be used with response_id"
-        end
-
-        model, tool_models = get_structured_output_models(parsed)
-
-        unwrap = -> (raw) do
-          if raw[:type] == "response.completed" && raw[:response]
-            parse_structured_outputs!(raw[:response], model, tool_models)
-          end
-
-          raw
-        end
-
-        if response_id
-          retrieve_params = parsed.slice(:include, :starting_after)
-          retrieve_params[:request_options] = options
-
-          raw_stream = retrieve_streaming_internal(
-            response_id,
-            params: retrieve_params,
-            unwrap: unwrap
-          )
-        else
-          parsed[:stream] = true
-
-          raw_stream = @client.request(
-            method: :post,
-            path: "responses",
-            headers: {"accept" => "text/event-stream"},
-            body: parsed,
-            stream: OpenAI::Internal::Stream,
-            model: OpenAI::Models::Responses::ResponseStreamEvent,
-            unwrap: unwrap,
-            security: {bearer_auth: true},
-            options: options
-          )
-        end
-
-        OpenAI::Streaming::ResponseStream.new(
-          raw_stream: raw_stream,
-          text_format: model,
-          starting_after: starting_after
-        )
-      end
-
       # See {OpenAI::Resources::Responses#create} for non-streaming counterpart.
       #
       # Creates a model response. Provide
@@ -376,7 +340,10 @@ module OpenAI
       # [file search](https://developers.openai.com/api/docs/guides/tools-file-search)
       # to use your own data as input for the model's response.
       #
-      # @overload stream(background: nil, context_management: nil, conversation: nil, include: nil, input: nil, instructions: nil, max_output_tokens: nil, max_tool_calls: nil, metadata: nil, model: nil, moderation: nil, parallel_tool_calls: nil, previous_response_id: nil, prompt: nil, prompt_cache_key: nil, prompt_cache_options: nil, prompt_cache_retention: nil, reasoning: nil, response_id: nil, safety_identifier: nil, service_tier: nil, starting_after: nil, store: nil, stream_options: nil, temperature: nil, text: nil, tool_choice: nil, tools: nil, top_logprobs: nil, top_p: nil, truncation: nil, user: nil, request_options: {})
+      # @overload stream_raw(access_programs: nil, background: nil, context_management: nil, conversation: nil, include: nil, input: nil, instructions: nil, max_output_tokens: nil, max_tool_calls: nil, metadata: nil, model: nil, moderation: nil, parallel_tool_calls: nil, previous_response_id: nil, prompt: nil, prompt_cache_key: nil, prompt_cache_options: nil, prompt_cache_retention: nil, reasoning: nil, safety_identifier: nil, service_tier: nil, store: nil, stream_options: nil, temperature: nil, text: nil, tool_choice: nil, tools: nil, top_logprobs: nil, top_p: nil, truncation: nil, user: nil, request_options: {})
+      #
+      # @param access_programs [OpenAI::Models::Responses::ResponseCreateParams::AccessPrograms]
+      #   Domain-specific access programs to use for this request.
       #
       # @param background [Boolean, nil]
       #   Whether to run the model response in the background.
@@ -513,7 +480,7 @@ module OpenAI
       # @param safety_identifier [String, nil]
       #   A stable identifier used to help detect users of your application that may be
       #   violating OpenAI's usage policies. The IDs should be a string that uniquely
-      #   identifies each user, with a maximum length of 64 characters. We recommend
+      #   identifies each user, with a maximum length of 128 characters. We recommend
       #   hashing their username or email address, in order to avoid sending us any
       #   identifying information.
       #   [Learn more](https://developers.openai.com/api/docs/guides/safety-best-practices#implement-safety-identifiers).
@@ -672,13 +639,13 @@ module OpenAI
       # @param starting_after [Integer]
       #   The sequence number of the event after which to start streaming.
       #
-      # @param text [OpenAI::Responses::ResponseTextConfig, OpenAI::StructuredOutput::JsonSchemaConverter, Hash, nil] The structured-output model,
-      #   or the same typed/hash text configuration accepted by creation, used to parse retrieved text output. This is a local parsing hint and is not
-      #   sent to the API.
+      # @param text [OpenAI::Responses::ResponseTextConfig, OpenAI::StructuredOutput::JsonSchemaConverter, Hash, nil]
+      #   The structured-output model used to parse retrieved text output. This is a local
+      #   parsing hint and is not sent to the API.
       #
-      # @param tools [Array<OpenAI::Responses::FunctionTool, OpenAI::StructuredOutput::JsonSchemaConverter, Hash>, nil] Structured-output models, or
-      #   the same typed/hash function-tool definitions accepted by creation, used to parse retrieved function tool calls. These are local parsing hints
-      #   and are not sent to the API.
+      # @param tools [Array<OpenAI::Responses::FunctionTool, OpenAI::StructuredOutput::JsonSchemaConverter, Hash>, nil]
+      #   Structured-output models used to parse retrieved function tool calls. These are
+      #   local parsing hints and are not sent to the API.
       #
       # @param request_options [OpenAI::RequestOptions, Hash{Symbol=>Object}, nil]
       #
@@ -765,22 +732,6 @@ module OpenAI
         )
       end
 
-      private def retrieve_streaming_internal(response_id, params:, unwrap:)
-        parsed, options = OpenAI::Responses::ResponseRetrieveParams.dump_request(params)
-        parsed.store(:stream, true)
-        @client.request(
-          method: :get,
-          path: ["responses/%1$s", response_id],
-          query: parsed,
-          headers: {"accept" => "text/event-stream"},
-          stream: OpenAI::Internal::Stream,
-          model: OpenAI::Responses::ResponseStreamEvent,
-          security: {bearer_auth: true},
-          options: options,
-          unwrap: unwrap
-        )
-      end
-
       # Deletes a model response with the given ID.
       #
       # @overload delete(response_id, request_options: {})
@@ -910,32 +861,30 @@ module OpenAI
         )
       end
 
-      # @api private
-      #
-      # @param client [OpenAI::Client]
-      def initialize(client:)
-        @client = client
-        @input_items = OpenAI::Resources::Responses::InputItems.new(client: client)
-        @input_tokens = OpenAI::Resources::Responses::InputTokens.new(client: client)
-      end
-
-      private
-
-      def parse_structured_outputs!(raw, model, tool_models)
+      private def parse_structured_outputs!(raw, model, tool_models)
         OpenAI::Helpers::StructuredOutput::ResponseParser.parse!(raw, model, tool_models)
       end
 
-      def parse_retrieved_structured_outputs!(raw, model, tool_models)
+      private def parse_retrieved_structured_outputs!(raw, model, tool_models)
         OpenAI::Helpers::StructuredOutput::ResponseParser.parse_retrieved!(raw, model, tool_models)
       end
 
-      def get_structured_output_models(parsed)
+      private def get_structured_output_models(parsed)
         OpenAI::Helpers::StructuredOutput::ResponseParser.get_models(parsed)
       end
 
-      def get_retrieval_structured_output_models(parsed)
+      private def get_retrieval_structured_output_models(parsed)
         OpenAI::Helpers::StructuredOutput::ResponseParser.get_retrieval_models(parsed)
       end
+
+      # @api private
+      #
+      # @param client [OpenAI::Client]
+      def initialize(client:)
+        @client = client
+        @input_items = OpenAI::Resources::Responses::InputItems.new(client: client)
+        @input_tokens = OpenAI::Resources::Responses::InputTokens.new(client: client)
+      end
     end
   end
 end

data/lib/openai/resources/vector_stores/file_batches.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../helpers/resource_polling"
-
 module OpenAI
   module Resources
     class VectorStores
@@ -58,63 +56,6 @@ module OpenAI
           )
         end
 
-        # Create a vector store file batch and wait for processing to finish.
-        #
-        # The returned batch may have a `failed` or `cancelled` status; callers should
-        # inspect its status and file counts. 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, attributes: nil, chunking_strategy: nil, file_ids: nil, files: 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 Batch.
-        #
-        # @param attributes [Hash{Symbol=>String, Float, Boolean}, nil] Attributes to apply to each file in `file_ids`.
-        #
-        # @param chunking_strategy [OpenAI::Models::AutoFileChunkingStrategyParam, OpenAI::Models::StaticFileChunkingStrategyObjectParam] The chunking strategy used to chunk the files.
-        #
-        # @param file_ids [Array<String>] File IDs to add to the vector store.
-        #
-        # @param files [Array<OpenAI::Models::VectorStores::FileBatchCreateParams::File>] File IDs with per-file attributes or chunking strategies.
-        #
-        # @param poll_interval [Integer, Float, nil] How often to retrieve the batch. 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::VectorStoreFileBatch]
-        def create_and_poll(
-          vector_store_id,
-          attributes: nil,
-          chunking_strategy: nil,
-          file_ids: nil,
-          files: nil,
-          poll_interval: nil,
-          timeout: OpenAI::Internal::Poller::DEFAULT_TIMEOUT,
-          request_options: {}
-        )
-          OpenAI::Internal::Poller.validate!(poll_interval: poll_interval, timeout: timeout)
-
-          params = {request_options: request_options}
-          params[:attributes] = attributes unless attributes.nil?
-          params[:chunking_strategy] = chunking_strategy unless chunking_strategy.nil?
-          params[:file_ids] = file_ids unless file_ids.nil?
-          params[:files] = files unless files.nil?
-          batch = create(vector_store_id, params)
-          poll(
-            batch.id,
-            vector_store_id: vector_store_id,
-            poll_interval: poll_interval,
-            timeout: timeout,
-            request_options: request_options
-          )
-        end
-
         # Retrieves a vector store file batch.
         #
         # @overload retrieve(batch_id, vector_store_id:, request_options: {})
@@ -236,125 +177,6 @@ module OpenAI
           )
         end
 
-        # Wait for a vector store file batch to finish processing.
-        #
-        # The returned batch may have a `failed` or `cancelled` status; callers should
-        # inspect its status and file counts. Polling intervals and the overall timeout
-        # are in seconds. Set `timeout` to `nil` to wait indefinitely.
-        #
-        # @overload poll(batch_id, vector_store_id:, poll_interval: nil, timeout: 1800.0, request_options: {})
-        #
-        # @param batch_id [String] The ID of the file batch being retrieved.
-        #
-        # @param vector_store_id [String] The ID of the vector store that the file batch belongs to.
-        #
-        # @param poll_interval [Integer, Float, nil] How often to retrieve the batch. 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::VectorStoreFileBatch]
-        def poll(
-          batch_id,
-          vector_store_id:,
-          poll_interval: nil,
-          timeout: OpenAI::Internal::Poller::DEFAULT_TIMEOUT,
-          request_options: {}
-        )
-          OpenAI::Helpers::ResourcePolling.poll_vector_store_file_batch(
-            self,
-            batch_id,
-            vector_store_id: vector_store_id,
-            poll_interval: poll_interval,
-            timeout: timeout,
-            request_options: request_options
-          )
-        end
-
-        # Upload files concurrently, create a vector store file batch, and wait for
-        # processing to finish.
-        #
-        # Existing file IDs can be included alongside new uploads. Upload concurrency is
-        # bounded and defaults to 5. Set `max_concurrency` to 1 for sequential uploads.
-        # Inputs are enumerated before requests begin so the 2,000-file API limit can be
-        # checked without orphaning uploads. Stream-backed inputs are safely spooled during
-        # enumeration, including IO objects yielded from block-scoped enumerators.
-        #
-        # @overload upload_and_poll(vector_store_id, files:, file_ids: [], max_concurrency: 5, 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 Batch.
-        #
-        # @param files [Enumerable<Pathname, StringIO, IO, String, OpenAI::FilePart>] Files to upload.
-        #
-        # @param file_ids [Array<String>] IDs of files that have already been uploaded.
-        #
-        # @param max_concurrency [Integer] Maximum number of simultaneous file uploads.
-        #
-        # @param attributes [Hash{Symbol=>String, Float, Boolean}, nil] Attributes to apply to every file.
-        #
-        # @param chunking_strategy [OpenAI::Models::AutoFileChunkingStrategyParam, OpenAI::Models::StaticFileChunkingStrategyObjectParam] The chunking strategy used to chunk the files.
-        #
-        # @param poll_interval [Integer, Float, nil] How often to retrieve the batch. 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 every upload and to the
-        #   batch creation and polling requests. Idempotency keys are scoped to each
-        #   upload and the batch creation.
-        #
-        # @raise [ArgumentError, OpenAI::Errors::PollingError]
-        # @return [OpenAI::Models::VectorStores::VectorStoreFileBatch]
-        def upload_and_poll(
-          vector_store_id,
-          files:,
-          file_ids: [],
-          max_concurrency: 5,
-          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)
-          request_options_scope = OpenAI::Internal::RequestOptionsScope.new(request_options)
-
-          max_files = OpenAI::Internal::VectorStoreFileUploader::MAX_FILES_PER_BATCH
-          if file_ids.length > max_files
-            raise ArgumentError, "`file_ids` cannot contain more than #{max_files} entries"
-          end
-
-          uploaded = OpenAI::Internal::VectorStoreFileUploader
-            .new(
-              client: @client,
-              max_concurrency: max_concurrency,
-              request_options: request_options
-            )
-            .upload(files, max_files: max_files - file_ids.length)
-
-          if uploaded.empty?
-            raise(
-              ArgumentError,
-              "No `files` provided. Use `create_and_poll` when all files are already uploaded."
-            )
-          end
-
-          create_and_poll(
-            vector_store_id,
-            file_ids: [*file_ids, *uploaded.map(&:id)],
-            attributes: attributes,
-            chunking_strategy: chunking_strategy,
-            poll_interval: poll_interval,
-            timeout: timeout,
-            request_options: request_options_scope.child("file-batch")
-          )
-        end
-
         # @api private
         #
         # @param client [OpenAI::Client]

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "../../helpers/resource_polling"
-
 module OpenAI
   module Resources
     class VectorStores
@@ -51,58 +49,6 @@ module OpenAI
           )
         end
 
-        # 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
-
         # Retrieves a vector store file.
         #
         # @overload retrieve(file_id, vector_store_id:, request_options: {})
@@ -257,140 +203,6 @@ module OpenAI
           )
         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
-
         # Retrieve the parsed contents of a vector store file.
         #
         # @overload content(file_id, vector_store_id:, request_options: {})