chore(internal): allow streams to also be unwrapped on a per-row basis

Author: stainless-app[bot]

lib/openai/internal/stream.rb

@@ -47,7 +47,8 @@ class Stream
                   message: message
                 )
               in decoded
-                y << OpenAI::Internal::Type::Converter.coerce(@model, decoded)
+                unwrapped = OpenAI::Internal::Util.dig(decoded, @unwrap)
+                y << OpenAI::Internal::Type::Converter.coerce(@model, unwrapped)
               end
             else
             end

lib/openai/internal/transport/base_client.rb

@@ -471,6 +471,7 @@ def request(req)
           self.class.validate!(req)
           model = req.fetch(:model) { OpenAI::Internal::Type::Unknown }
           opts = req[:options].to_h
+          unwrap = req[:unwrap]
           OpenAI::RequestOptions.validate!(opts)
           request = build_request(req.except(:options), opts)
           url = request.fetch(:url)
@@ -487,11 +488,18 @@ def request(req)
           decoded = OpenAI::Internal::Util.decode_content(response, stream: stream)
           case req
           in {stream: Class => st}
-            st.new(model: model, url: url, status: status, response: response, stream: decoded)
+            st.new(
+              model: model,
+              url: url,
+              status: status,
+              response: response,
+              unwrap: unwrap,
+              stream: decoded
+            )
           in {page: Class => page}
             page.new(client: self, req: req, headers: response, page_data: decoded)
           else
-            unwrapped = OpenAI::Internal::Util.dig(decoded, req[:unwrap])
+            unwrapped = OpenAI::Internal::Util.dig(decoded, unwrap)
             OpenAI::Internal::Type::Converter.coerce(model, unwrapped)
           end
         end

lib/openai/internal/type/base_stream.rb

@@ -64,12 +64,14 @@ def to_enum = @iterator
         # @param url [URI::Generic]
         # @param status [Integer]
         # @param response [Net::HTTPResponse]
+        # @param unwrap [Symbol, Integer, Array<Symbol, Integer>, Proc]
         # @param stream [Enumerable<Object>]
-        def initialize(model:, url:, status:, response:, stream:)
+        def initialize(model:, url:, status:, response:, unwrap:, stream:)
           @model = model
           @url = url
           @status = status
           @response = response
+          @unwrap = unwrap
           @stream = stream
           @iterator = iterator
 

rbi/openai/internal/type/base_stream.rbi

@@ -52,10 +52,17 @@ module OpenAI
             url: URI::Generic,
             status: Integer,
             response: Net::HTTPResponse,
+            unwrap:
+              T.any(
+                Symbol,
+                Integer,
+                T::Array[T.any(Symbol, Integer)],
+                T.proc.params(arg0: T.anything).returns(T.anything)
+              ),
             stream: T::Enumerable[Message]
           ).void
         end
-        def initialize(model:, url:, status:, response:, stream:)
+        def initialize(model:, url:, status:, response:, unwrap:, stream:)
         end
 
         # @api private

sig/openai/internal/type/base_stream.rbs

@@ -23,6 +23,10 @@ module OpenAI
           url: URI::Generic,
           status: Integer,
           response: top,
+          unwrap: Symbol
+          | Integer
+          | ::Array[Symbol | Integer]
+          | ^(top arg0) -> top,
           stream: Enumerable[Message]
         ) -> void