feat: expose recursive #to_h conversion

Author: stainless-app[bot]

lib/openai/internal/type/base_model.rb

@@ -306,6 +306,39 @@ def dump(value, state:)
           end
         end
 
+        class << self
+          # @api private
+          #
+          # @param model [OpenAI::Internal::Type::BaseModel]
+          # @param convert [Boolean]
+          #
+          # @return [Hash{Symbol=>Object}]
+          def recursively_to_h(model, convert:)
+            rec = ->(x) do
+              case x
+              in OpenAI::Internal::Type::BaseModel
+                if convert
+                  fields = x.class.known_fields
+                  x.to_h.to_h do |key, val|
+                    [key, rec.call(fields.key?(key) ? x.public_send(key) : val)]
+                  rescue OpenAI::Errors::ConversionError
+                    [key, rec.call(val)]
+                  end
+                else
+                  rec.call(x.to_h)
+                end
+              in Hash
+                x.transform_values(&rec)
+              in Array
+                x.map(&rec)
+              else
+                x
+              end
+            end
+            rec.call(model)
+          end
+        end
+
         # @api public
         #
         # Returns the raw value associated with the given key, if found. Otherwise, nil is
@@ -342,6 +375,14 @@ def to_h = @data
 
         alias_method :to_hash, :to_h
 
+        # @api public
+        #
+        # In addition to the behaviour of `#to_h`, this method will recursively call
+        # `#to_h` on nested models.
+        #
+        # @return [Hash{Symbol=>Object}]
+        def deep_to_h = self.class.recursively_to_h(@data, convert: false)
+
         # @param keys [Array<Symbol>, nil]
         #
         # @return [Hash{Symbol=>Object}]
@@ -357,29 +398,6 @@ def deconstruct_keys(keys)
             .to_h
         end
 
-        class << self
-          # @api private
-          #
-          # @param model [OpenAI::Internal::Type::BaseModel]
-          #
-          # @return [Hash{Symbol=>Object}]
-          def walk(model)
-            walk = ->(x) do
-              case x
-              in OpenAI::Internal::Type::BaseModel
-                walk.call(x.to_h)
-              in Hash
-                x.transform_values(&walk)
-              in Array
-                x.map(&walk)
-              else
-                x
-              end
-            end
-            walk.call(model)
-          end
-        end
-
         # @api public
         #
         # @param a [Object]
@@ -425,12 +443,15 @@ def inspect(depth: 0)
         # @api public
         #
         # @return [String]
-        def to_s = self.class.walk(@data).to_s
+        def to_s = deep_to_h.to_s
 
         # @api private
         #
         # @return [String]
-        def inspect = "#<#{self.class}:0x#{object_id.to_s(16)} #{self}>"
+        def inspect
+          converted = self.class.recursively_to_h(self, convert: true)
+          "#<#{self.class}:0x#{object_id.to_s(16)} #{converted}>"
+        end
 
         define_sorbet_constant!(:KnownField) do
           T.type_alias { {mode: T.nilable(Symbol), required: T::Boolean, nilable: T::Boolean} }

rbi/openai/internal/type/base_model.rbi

@@ -192,6 +192,18 @@ module OpenAI
           end
         end
 
+        class << self
+          # @api private
+          sig do
+            params(
+              model: OpenAI::Internal::Type::BaseModel,
+              convert: T::Boolean
+            ).returns(OpenAI::Internal::AnyHash)
+          end
+          def recursively_to_h(model, convert:)
+          end
+        end
+
         # Returns the raw value associated with the given key, if found. Otherwise, nil is
         # returned.
         #
@@ -226,6 +238,12 @@ module OpenAI
         def to_hash
         end
 
+        # In addition to the behaviour of `#to_h`, this method will recursively call
+        # `#to_h` on nested models.
+        sig { overridable.returns(OpenAI::Internal::AnyHash) }
+        def deep_to_h
+        end
+
         sig do
           params(keys: T.nilable(T::Array[Symbol])).returns(
             OpenAI::Internal::AnyHash
@@ -234,17 +252,6 @@ module OpenAI
         def deconstruct_keys(keys)
         end
 
-        class << self
-          # @api private
-          sig do
-            params(model: OpenAI::Internal::Type::BaseModel).returns(
-              OpenAI::Internal::AnyHash
-            )
-          end
-          def walk(model)
-          end
-        end
-
         sig { params(a: T.anything).returns(String) }
         def to_json(*a)
         end

sig/openai/internal/type/base_model.rbs

@@ -68,17 +68,20 @@ module OpenAI
           state: OpenAI::Internal::Type::Converter::dump_state
         ) -> (::Hash[top, top] | top)
 
+        def self.recursively_to_h: (
+          OpenAI::Internal::Type::BaseModel model,
+          convert: bool
+        ) -> ::Hash[Symbol, top]
+
         def []: (Symbol key) -> top?
 
         def to_h: -> ::Hash[Symbol, top]
 
         alias to_hash to_h
 
-        def deconstruct_keys: (::Array[Symbol]? keys) -> ::Hash[Symbol, top]
+        def deep_to_h: -> ::Hash[Symbol, top]
 
-        def self.walk: (
-          OpenAI::Internal::Type::BaseModel model
-        ) -> ::Hash[Symbol, top]
+        def deconstruct_keys: (::Array[Symbol]? keys) -> ::Hash[Symbol, top]
 
         def to_json: (*top a) -> String