sorbet-baml 0.4.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4de7b80da4ee748d5c22196c22f78ca92e855f9b4983437d4ea6ad02a5201fba
-  data.tar.gz: 22a81719e5d2021b52945d913e3134482ff999e917d655f67ec894a35fa2a40b
+  metadata.gz: '0853732b922565aa837ede825e6c074a29975d1fb7eb16140b699ec5db495e92'
+  data.tar.gz: 55f2775ead79f10978a7c7858889f124cd5c3e01f430b6cc7ff32f6484dad955
 SHA512:
-  metadata.gz: d64e1cef217666030c2f34cacd48333d6ce46d5fac40e2a2855c0f73fe43dadf39a620ad01b37df904ca5aa792a7d46cd3a1bdaf45ce797b34f3010ce4a2be12
-  data.tar.gz: 6131b255163a544f2ef7591f58e173ab0436c44426003513888b51ea4d3a35a5ff90d186b491d867035b9d0c86929b176c6ff8bfeb6de7106b87662546ea0c3e
+  metadata.gz: 4d519cf11e3cbdfebff145542b48a51fc2e90ebbbe841f047f3ba344de508d26efa27b248fcc3aa4ac9777870c3b94b208c53bd7d238fcbc291048a350b4275d
+  data.tar.gz: fc3b1ce2f6d829c49e0a0f2c7e16f6d46e211258e094c9f83deefbd0aeafd07f8797cb3e3366568b652b759722445eb45de84ecf95fa6aa40847279fc5748f7d

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.5.1] - 2026-03-07
+
+### Fixed
+
+- Avoid emitting invalid double optional markers like `int??` when converting DSPy tool parameters backed by `T.nilable(...)`
+- Add regression coverage for nilable scalar, enum, and enum-array DSPy tool parameters so malformed `??` output fails tests
+
+### Improved
+
+- Tighten DSPy tool conversion assertions to validate full rendered optional parameter lines instead of permissive substrings
+
 ## [0.4.0] - 2025-10-14
 
 ### Changed

data/lib/sorbet-baml.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'sorbet_baml'

data/lib/sorbet_baml/description_extractor.rb

@@ -16,12 +16,21 @@ module SorbetBaml
       return descriptions unless klass.respond_to?(:props)
 
       begin
-        T.unsafe(klass).props.each do |field_name, prop_info|
-          next unless prop_info.is_a?(Hash)
+        # DSPy >= 0.34 stores descriptions via DSPy::Ext::StructDescriptions#field_descriptions
+        if klass.respond_to?(:field_descriptions)
+          T.unsafe(klass).field_descriptions.each do |field_name, desc|
+            descriptions[field_name.to_s] = desc if desc.is_a?(String)
+          end
+        end
+
+        # Fall back to the legacy :extra hash for structs that store descriptions there
+        if descriptions.empty?
+          T.unsafe(klass).props.each do |field_name, prop_info|
+            next unless prop_info.is_a?(Hash)
 
-          # Check if the prop has a description in the :extra field
-          extra = prop_info[:extra]
-          descriptions[field_name.to_s] = extra[:description] if extra.is_a?(Hash) && extra[:description].is_a?(String)
+            extra = prop_info[:extra]
+            descriptions[field_name.to_s] = extra[:description] if extra.is_a?(Hash) && extra[:description].is_a?(String)
+          end
         end
       rescue StandardError
         # Handle any errors gracefully and return empty hash

data/lib/sorbet_baml/dspy_tool_converter.rb

@@ -26,25 +26,50 @@ module SorbetBaml
       tool_name = klass.tool_name_value || klass.name&.split('::')&.last
       tool_description = klass.tool_description_value
 
-      # Get parameters from DSPy's call_schema which extracts from Sorbet signatures
-      call_schema = klass.call_schema
+      # Get parameters from DSPy's call_schema_object which extracts from Sorbet signatures.
+      call_schema = klass.call_schema_object
       parameters = call_schema[:properties] || {}
       required_params = call_schema[:required] || []
 
+      # Extract Sorbet types directly from the call method signature for richer type info.
+      # This gives us access to T::Enum classes, T::Struct references, etc. that are lost
+      # when converting to JSON schema.
+      sorbet_types = extract_sorbet_types(klass)
+
+      # Collect enum classes referenced by parameters for generating enum definitions.
+      enum_classes = collect_enum_classes(sorbet_types)
+
       lines = []
 
       # Add tool description as class-level comment if available
       lines << "// #{tool_description}" if @include_descriptions && tool_description
 
+      # Generate enum definitions between description and class
+      if enum_classes.any?
+        lines << '' unless lines.empty?
+        enum_converter = Converter.new(@options)
+        enum_classes.each_with_index do |enum_klass, i|
+          lines << '' unless i.zero?
+          lines << enum_converter.convert_enum(enum_klass)
+        end
+        lines << ''
+      end
+
       # Generate BAML class definition
       lines << "class #{tool_name} {"
 
       parameters.each do |param_name, param_info|
-        # Convert JSON schema type to BAML type
-        baml_type = json_schema_type_to_baml(param_info)
-
-        # Add optional marker if parameter is not required
-        baml_type += '?' unless required_params.include?(param_name.to_s)
+        # Use Sorbet type mapping when available (preserves enum/struct type names).
+        # Fall back to JSON schema conversion for tools without Sorbet signatures.
+        baml_type = if sorbet_types.key?(param_name)
+                      TypeMapper.map_type(sorbet_types[param_name])
+                    else
+                      json_schema_type_to_baml(param_info)
+                    end
+
+        # TypeMapper already encodes T.nilable(...) as a trailing `?`.
+        # Avoid emitting invalid `??` when DSPy also marks the kwarg optional.
+        baml_type += '?' if !required_params.include?(param_name.to_s) && !baml_type.end_with?('?')
 
         line = "#{' ' * @indent_size}#{param_name} #{baml_type}"
 
@@ -63,10 +88,61 @@ module SorbetBaml
 
     private
 
+    # Extract Sorbet types from the tool's call method signature.
+    sig { params(klass: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
+    def extract_sorbet_types(klass)
+      method_obj = klass.instance_method(:call)
+      sig_info = T::Utils.signature_for_method(method_obj)
+      return {} if sig_info.nil?
+
+      types = {}
+      sig_info.arg_types.each { |name, type| types[name] = type }
+      sig_info.kwarg_types.each { |name, type| types[name] = type }
+      types
+    end
+
+    # Collect all T::Enum classes referenced by the given Sorbet types.
+    sig { params(sorbet_types: T::Hash[Symbol, T.untyped]).returns(T::Array[T.class_of(T::Enum)]) }
+    def collect_enum_classes(sorbet_types)
+      enum_classes = T.let([], T::Array[T.class_of(T::Enum)])
+      sorbet_types.each_value do |type|
+        enum_classes.concat(extract_enum_types(type))
+      end
+      enum_classes.uniq
+    end
+
+    # Recursively extract T::Enum classes from a Sorbet type object.
+    sig { params(type: T.untyped).returns(T::Array[T.class_of(T::Enum)]) }
+    def extract_enum_types(type)
+      case type
+      when T::Types::Simple
+        raw = type.raw_type
+        raw.is_a?(Class) && raw < T::Enum ? [raw] : []
+      when T::Types::TypedArray
+        extract_enum_types(type.type)
+      when T::Types::TypedHash
+        extract_enum_types(type.keys) + extract_enum_types(type.values)
+      else
+        if type.is_a?(Class) && type < T::Enum
+          [type]
+        elsif type.respond_to?(:types)
+          type.types.flat_map { |t| extract_enum_types(t) }
+        else
+          []
+        end
+      end
+    end
+
+    # Fallback: convert JSON schema type info to BAML type string.
+    # Used when Sorbet signature is not available.
     sig { params(json_schema_info: T::Hash[Symbol, T.untyped]).returns(String) }
     def json_schema_type_to_baml(json_schema_info)
       type = json_schema_info[:type]
 
+      # dspy >= 0.34 represents nilable types as ["integer", "null"] rather than just "integer".
+      # Extract the primary (non-null) type so the case below matches correctly.
+      type = type.reject { |t| t == 'null' }.first if type.is_a?(Array)
+
       case type
       when :string, 'string'
         'string'

data/lib/sorbet_baml/type_mapper.rb

@@ -19,6 +19,9 @@ module SorbetBaml
         map_array_type(type_object)
       when T::Types::TypedHash
         map_hash_type(type_object)
+      when T::Types::Untyped
+        # T.untyped maps to BAML's json type for dynamic values
+        'json'
       else
         # Check if it's a union type (T.nilable or T.any)
         if type_object.respond_to?(:types)
@@ -61,8 +64,10 @@ module SorbetBaml
     sig { params(type_object: T.untyped).returns(String) }
     def self.map_union_type(type_object)
       types = type_object.types
-      nil_type = types.find { |t| t.raw_type == NilClass }
-      non_nil_types = types.reject { |t| t.raw_type == NilClass }
+
+      # Only T::Types::Simple has raw_type - check type class before accessing
+      nil_type = types.find { |t| nil_type?(t) }
+      non_nil_types = types.reject { |t| nil_type?(t) }
 
       return 'null' if non_nil_types.empty?
 
@@ -91,6 +96,13 @@ module SorbetBaml
       end
     end
 
+    # Check if a type represents NilClass safely
+    # Only T::Types::Simple has raw_type; other type classes (TypedHash, TypedArray, Untyped) do not
+    sig { params(type_obj: T.untyped).returns(T::Boolean) }
+    def self.nil_type?(type_obj)
+      type_obj.is_a?(T::Types::Simple) && type_obj.raw_type == NilClass || false
+    end
+
     sig { params(type_object: T.untyped).returns(String) }
     def self.map_array_type(type_object)
       element_type = map_type(type_object.type)

data/lib/sorbet_baml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SorbetBaml
-  VERSION = '0.4.0'
+  VERSION = '0.5.1'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sorbet-baml
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Vicente Reig Rincon de Arellano
 bindir: exe
 cert_chain: []
-date: 2025-10-14 00:00:00.000000000 Z
+date: 2026-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
@@ -38,6 +38,7 @@ files:
 - README.md
 - Rakefile
 - examples/description_parameters.rb
+- lib/sorbet-baml.rb
 - lib/sorbet_baml.rb
 - lib/sorbet_baml/comment_extractor.rb
 - lib/sorbet_baml/converter.rb