openai 0.103.0 → 0.104.0

data/lib/openai/helpers/models/responses/response.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../../../models/responses/response"
+
+module OpenAI
+  module Models
+    module Responses
+      class Response
+        # Convenience property that aggregates all `output_text` items from the `output` list.
+        #
+        # If no `output_text` content blocks exist, then an empty string is returned.
+        #
+        # @return [String]
+        def output_text
+          texts = []
+
+          output.each do |item|
+            next unless item.is_a?(OpenAI::Models::Responses::ResponseOutputMessage)
+
+            item.content.each do |content|
+              next unless content.is_a?(OpenAI::Models::Responses::ResponseOutputText)
+
+              texts << content.text
+            end
+          end
+
+          texts.join
+        end
+      end
+    end
+  end
+end

data/lib/openai/helpers/models/webhooks/webhook_endpoint_with_secret.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative "../../../models/webhooks/webhook_endpoint_with_secret"
+
+module OpenAI
+  module Models
+    module Webhooks
+      class WebhookEndpointWithSecret
+        # Keep diagnostics safe without changing field access or serialization.
+        def to_s = deep_to_h.merge(signing_secret: "[REDACTED]").to_s
+
+        def inspect
+          converted = self.class.recursively_to_h(self, convert: true)
+          converted[:signing_secret] = "[REDACTED]"
+          "#<#{self.class}:0x#{object_id.to_s(16)} #{converted}>"
+        end
+      end
+    end
+  end
+end

data/lib/openai/helpers/realtime/client_extension.rb

@@ -166,8 +166,7 @@ module OpenAI
           deadline: nil
         )
           build_shared_websocket_connection_request(
-            path: path,
-            query: query,
+            request: realtime.__websocket_request(query: query).merge(path: path),
             websocket_base_url: websocket_base_url,
             options: options,
             deadline: deadline,

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

@@ -25,7 +25,7 @@ module OpenAI
         base_url = websocket_base_url&.to_s&.dup&.freeze
         request = lambda do |&request_block|
           client.with_realtime_connection_request(
-            path: "realtime",
+            path: client.realtime.__websocket_request.fetch(:path),
             query: query,
             websocket_base_url: base_url,
             options: request_options,

data/lib/openai/helpers/realtime/translation.rb

@@ -53,6 +53,7 @@ module OpenAI
     # read through session.closed before leaving the block to consume it.
     class TranslationConnection < OpenAI::WebSocket::Connection
       include OpenAI::WebSocket::Protocol
+      include OpenAI::WebSocket::GuardedConnection
 
       # Timeout implementations before Ruby 4 raise StandardError through the
       # scheduler. Cross transport error wrappers without changing raw callers.
@@ -135,27 +136,6 @@ module OpenAI
         end
       end
 
-      def closed? = @poisoned || @closed || super
-
-      def close(code: 1000, reason: "")
-        @poisoned || @closed ? abort : super
-        @closed = true
-        nil
-      rescue StandardError
-        @poisoned = true
-        raise OpenAI::Errors::TranslationConnectionError.new(url: @url), cause: nil
-      end
-
-      # @api private
-      def abort
-        super
-        @closed = true
-        nil
-      rescue StandardError
-        @poisoned = true
-        raise OpenAI::Errors::TranslationConnectionError.new(url: @url), cause: nil
-      end
-
       private def write_text(text, finish: false)
         @write_mutex.synchronize do
           if @finish_requested || (@finish_owner && !finish)
@@ -164,18 +144,7 @@ module OpenAI
 
           raise connection_error("Cannot send on a closed Realtime Translation WebSocket.") if closed?
           @finish_requested = true if finish
-          complete = false
-          begin
-            super(text)
-            complete = true
-            nil
-          rescue StandardError
-            raise OpenAI::Errors::TranslationConnectionError.new(url: @url), cause: nil
-          ensure
-            # Ruby's Timeout and task cancellation may bypass StandardError.
-            # Do not let ordinary cleanup flush an uncertain buffered write.
-            @poisoned = true unless complete
-          end
+          super(text)
         end
       end
 
@@ -189,26 +158,12 @@ module OpenAI
         end
 
         begin
-          raise connection_error("Cannot read from a failed Realtime Translation WebSocket.") if @poisoned
-          return nil if @closed
-          text = super
-          @closed = text.nil?
-          text
-        rescue StandardError
-          @poisoned = true
-          raise OpenAI::Errors::TranslationConnectionError.new(url: @url), cause: nil
+          super
         ensure
           @read_state_mutex.synchronize { @active_reads -= 1 }
         end
       end
 
-      private def socket_closed?
-        super
-      rescue StandardError
-        @poisoned = true
-        raise OpenAI::Errors::TranslationConnectionError.new(url: @url), cause: nil
-      end
-
       private def encode_client_event(event)
         validate_client_tree!(event)
         union = OpenAI::Realtime::RealtimeTranslationClientEvent
@@ -337,6 +292,9 @@ module OpenAI
         event
       end
 
+      private def transport_error = OpenAI::Errors::TranslationConnectionError.new(url: @url)
+      private def failed_read_message = "Cannot read from a failed Realtime Translation WebSocket."
+
       private def connection_error(message)
         OpenAI::Errors::TranslationConnectionError.new(url: @url, message: message)
       end
@@ -352,8 +310,7 @@ module OpenAI
           query = {"model" => model.to_s.dup.freeze}.freeze
           build = lambda do |deadline|
             build_shared_websocket_connection_request(
-              path: "realtime/translations",
-              query: query,
+              request: realtime.translations.__websocket_request(query: query),
               websocket_base_url: websocket_base_url,
               options: options,
               deadline: deadline,

data/lib/openai/helpers/responses_websocket/client_extension.rb

@@ -29,8 +29,7 @@ module OpenAI
           deadline: nil
         )
           build_shared_websocket_connection_request(
-            path: "responses",
-            query: {},
+            request: responses.__websocket_request,
             websocket_base_url: websocket_base_url,
             options: options,
             deadline: deadline,

data/lib/openai/helpers/streaming/chat_completion_resource.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Resources
+    class Chat
+      class Completions
+        def stream(params)
+          parsed, options = OpenAI::Chat::CompletionCreateParams.dump_request(params)
+
+          parsed.store(:stream, true)
+
+          response_format, tool_models = get_structured_output_models(parsed)
+
+          input_tools = build_tools_with_models(parsed[:tools], tool_models)
+
+          raw_stream = @client.request(
+            method: :post,
+            path: "chat/completions",
+            headers: {"accept" => "text/event-stream"},
+            body: parsed,
+            stream: OpenAI::Internal::Stream,
+            model: OpenAI::Chat::ChatCompletionChunk,
+            security: {bearer_auth: true},
+            options: options
+          )
+
+          OpenAI::Helpers::Streaming::ChatCompletionStream.new(
+            raw_stream: raw_stream,
+            response_format: response_format,
+            input_tools: input_tools
+          )
+        end
+      end
+    end
+  end
+end

data/lib/openai/helpers/streaming/response_stream.rb

@@ -49,22 +49,7 @@ module OpenAI
           response
         end
 
-        def get_output_text
-          response = get_final_response
-          text_parts = []
-
-          response.output.each do |output|
-            next unless output.is_a?(OpenAI::Models::Responses::ResponseOutputMessage)
-
-            output.content.each do |content|
-              next unless content.is_a?(OpenAI::Models::Responses::ResponseOutputText)
-
-              text_parts << content.text
-            end
-          end
-
-          text_parts.join
-        end
+        def get_output_text = get_final_response.output_text
 
         private
 

data/lib/openai/helpers/streaming/response_stream_resource.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module OpenAI
+  module Resources
+    class Responses
+      # 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
+
+      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
+    end
+  end
+end

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

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+
+require_relative "../../resources/vector_stores/file_batches"
+require_relative "../resource_polling"
+
+module OpenAI
+  module Resources
+    class VectorStores
+      class FileBatches
+        # 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
+
+        # 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
+      end
+    end
+  end
+end