dspy 0.27.4 → 0.27.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dca273acbd2ba8ab0ab9e2980bdf8048cc9ea80b3ce1b74d6f1e911e165ae895
-  data.tar.gz: '08177e7841275140c7f074ac3a700883f06c6610c9bfd4795d142a3c838c0b24'
+  metadata.gz: ccadc1d2803420cbc9389d9f4312b6b6e616e133d4e35f36454135292fd8e837
+  data.tar.gz: e174d2cd9418a0294890e1ca6d3599681ba26c2a09c081f3b2b6652e6ce8c88d
 SHA512:
-  metadata.gz: 1b8d4bd756ab303688366fb0bcb5e5a3e045152c5695a8cdcd5291ca6313fc8ee7bd8051c6026663cfda0ec429b7977aa2355442595ba803bfedafd3926e89b6
-  data.tar.gz: 30efa43a8bc34708003a178d7715ae6688268b4b63e98789f011e47f7d36b8c30f292ac986c8df3767bafa517b7b73f5ff7fa92fec8013732c69952dfa79df71
+  metadata.gz: fa7eefd5f7d5555ce057f0e204b6aa5bac1188e2633c202abdf9decc75eee75ae5a232550c368dcba081fe32cc54e0d9aa8db6d565b280c260bd0b8beacff4d9
+  data.tar.gz: 5b16c7fe7ebbe678e16235e0b0b857d3b017deb7a7eea1e6e032b4b839fbde33b4bae86fd3e50d2b6f49c114303231f60441d43d931c8f0cda3c9f5e72d786ab

data/lib/dspy/lm/strategies/anthropic_tool_use_strategy.rb

@@ -119,72 +119,12 @@ module DSPy
         sig { params(fields: T::Hash[Symbol, T.untyped]).returns(T::Hash[String, T.untyped]) }
         def build_properties_from_fields(fields)
           properties = {}
-          
-          fields.each do |field_name, descriptor|
-            properties[field_name.to_s] = convert_type_to_json_schema(descriptor.type)
-          end
-          
-          properties
-        end
 
-        sig { params(type: T.untyped).returns(T::Hash[String, T.untyped]) }
-        def convert_type_to_json_schema(type)
-          # Handle raw Ruby class types - use === for class comparison
-          if type == String
-            return { type: "string" }
-          elsif type == Integer
-            return { type: "integer" }
-          elsif type == Float
-            return { type: "number" }
-          elsif type == TrueClass || type == FalseClass
-            return { type: "boolean" }
-          end
-          
-          # Handle Sorbet types
-          case type
-          when T::Types::Simple
-            case type.raw_type.to_s
-            when "String"
-              { type: "string" }
-            when "Integer"
-              { type: "integer" }
-            when "Float", "Numeric"
-              { type: "number" }
-            when "TrueClass", "FalseClass"
-              { type: "boolean" }
-            else
-              { type: "string" } # Default fallback
-            end
-          when T::Types::TypedArray
-            {
-              type: "array",
-              items: convert_type_to_json_schema(type.type)
-            }
-          when T::Types::TypedHash
-            {
-              type: "object",
-              additionalProperties: convert_type_to_json_schema(type.values)
-            }
-          else
-            # For complex types, try to introspect
-            if type.respond_to?(:props)
-              {
-                type: "object",
-                properties: build_properties_from_props(type.props)
-              }
-            else
-              { type: "object" } # Generic object fallback
-            end
+          fields.each do |field_name, descriptor|
+            properties[field_name.to_s] = DSPy::TypeSystem::SorbetJsonSchema.type_to_json_schema(descriptor.type)
           end
-        end
 
-        sig { params(props: T.untyped).returns(T::Hash[String, T.untyped]) }
-        def build_properties_from_props(props)
-          result = {}
-          props.each do |prop_name, prop_info|
-            result[prop_name.to_s] = convert_type_to_json_schema(prop_info[:type])
-          end
-          result
+          properties
         end
       end
     end

data/lib/dspy/re_act.rb

@@ -369,13 +369,22 @@ module DSPy
     sig { params(input_kwargs: T::Hash[Symbol, T.untyped], reasoning_result: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
     def create_enhanced_result(input_kwargs, reasoning_result)
       output_field_name = @original_signature_class.output_struct_class.props.keys.first
+      final_answer = reasoning_result[:final_answer]
 
       output_data = input_kwargs.merge({
         history: reasoning_result[:history].map(&:to_h),
         iterations: reasoning_result[:iterations],
         tools_used: reasoning_result[:tools_used]
       })
-      output_data[output_field_name] = reasoning_result[:final_answer]
+
+      # Check if final_answer is a String but the expected type is NOT String
+      # This happens when max iterations is reached or the LLM generates an error message
+      output_field_type = @original_signature_class.output_struct_class.props[output_field_name][:type_object]
+      if final_answer.is_a?(String) && !string_compatible_type?(output_field_type)
+        output_data[output_field_name] = default_value_for_type(output_field_type)
+      else
+        output_data[output_field_name] = final_answer
+      end
 
       @enhanced_output_struct.new(**output_data)
     end
@@ -502,6 +511,56 @@ module DSPy
       "No answer reached within #{@max_iterations} iterations"
     end
 
+    # Checks if a type is String or compatible with String (e.g., T.any(String, ...) or T.nilable(String))
+    sig { params(type_object: T.untyped).returns(T::Boolean) }
+    def string_compatible_type?(type_object)
+      case type_object
+      when T::Types::Simple
+        type_object.raw_type == String
+      when T::Types::Union
+        # Check if any of the union types is String
+        type_object.types.any? { |t| t.is_a?(T::Types::Simple) && t.raw_type == String }
+      else
+        false
+      end
+    end
+
+    # Returns an appropriate default value for a given Sorbet type
+    # This is used when max iterations is reached without a successful completion
+    sig { params(type_object: T.untyped).returns(T.untyped) }
+    def default_value_for_type(type_object)
+      # Handle TypedArray (T::Array[...])
+      if type_object.is_a?(T::Types::TypedArray)
+        return []
+      end
+
+      # Handle TypedHash (T::Hash[...])
+      if type_object.is_a?(T::Types::TypedHash)
+        return {}
+      end
+
+      # Handle simple types
+      case type_object
+      when T::Types::Simple
+        raw_type = type_object.raw_type
+        case raw_type.to_s
+        when 'String' then ''
+        when 'Integer' then 0
+        when 'Float' then 0.0
+        when 'TrueClass', 'FalseClass' then false
+        else
+          # For T::Struct types, return nil as fallback
+          nil
+        end
+      when T::Types::Union
+        # For unions, return nil (assuming it's nilable) or first non-nil default
+        nil
+      else
+        # Default fallback for unknown types
+        nil
+      end
+    end
+
     # Tool execution method
     sig { params(action: String, action_input: T.untyped).returns(String) }
     def execute_action(action, action_input)

data/lib/dspy/signature.rb

@@ -133,7 +133,7 @@ module DSPy
         required = []
 
         @input_field_descriptors&.each do |name, descriptor|
-          schema = type_to_json_schema(descriptor.type)
+          schema = DSPy::TypeSystem::SorbetJsonSchema.type_to_json_schema(descriptor.type)
           schema[:description] = descriptor.description if descriptor.description
           properties[name] = schema
           required << name.to_s unless descriptor.has_default
@@ -160,7 +160,7 @@ module DSPy
         required = []
 
         @output_field_descriptors&.each do |name, descriptor|
-          schema = type_to_json_schema(descriptor.type)
+          schema = DSPy::TypeSystem::SorbetJsonSchema.type_to_json_schema(descriptor.type)
           schema[:description] = descriptor.description if descriptor.description
           properties[name] = schema
           required << name.to_s unless descriptor.has_default
@@ -178,255 +178,6 @@ module DSPy
       def output_schema
         @output_struct_class
       end
-
-      private
-
-      sig { params(type: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
-      def type_to_json_schema(type)
-        # Handle T::Boolean type alias first
-        if type == T::Boolean
-          return { type: "boolean" }
-        end
-
-        # Handle type aliases by resolving to their underlying type
-        if type.is_a?(T::Private::Types::TypeAlias)
-          return type_to_json_schema(type.aliased_type)
-        end
-
-        # Handle raw class types first
-        if type.is_a?(Class)
-          if type < T::Enum
-            # Get all enum values
-            values = type.values.map(&:serialize)
-            { type: "string", enum: values }
-          elsif type == String
-            { type: "string" }
-          elsif type == Integer
-            { type: "integer" }
-          elsif type == Float
-            { type: "number" }
-          elsif type == Numeric
-            { type: "number" }
-          elsif type == Date
-            { type: "string", format: "date" }
-          elsif type == DateTime
-            { type: "string", format: "date-time" }
-          elsif type == Time
-            { type: "string", format: "date-time" }
-          elsif [TrueClass, FalseClass].include?(type)
-            { type: "boolean" }
-          elsif type < T::Struct
-            # Handle custom T::Struct classes by generating nested object schema
-            generate_struct_schema(type)
-          else
-            { type: "string" }  # Default fallback
-          end
-        elsif type.is_a?(T::Types::Simple)
-          case type.raw_type.to_s
-          when "String"
-            { type: "string" }
-          when "Integer"
-            { type: "integer" }
-          when "Float"
-            { type: "number" }
-          when "Numeric"
-            { type: "number" }
-          when "Date"
-            { type: "string", format: "date" }
-          when "DateTime"
-            { type: "string", format: "date-time" }
-          when "Time"
-            { type: "string", format: "date-time" }
-          when "TrueClass", "FalseClass"
-            { type: "boolean" }
-          when "T::Boolean"
-            { type: "boolean" }
-          else
-            # Check if it's an enum
-            if type.raw_type < T::Enum
-              # Get all enum values
-              values = type.raw_type.values.map(&:serialize)
-              { type: "string", enum: values }
-            elsif type.raw_type < T::Struct
-              # Handle custom T::Struct classes
-              generate_struct_schema(type.raw_type)
-            else
-              { type: "string" }  # Default fallback
-            end
-          end
-        elsif type.is_a?(T::Types::TypedArray)
-          # Handle arrays properly with nested item type
-          {
-            type: "array",
-            items: type_to_json_schema(type.type)
-          }
-        elsif type.is_a?(T::Types::TypedHash)
-          # Handle hashes as objects with additionalProperties
-          # TypedHash has keys and values methods to access its key and value types
-          key_schema = type_to_json_schema(type.keys)
-          value_schema = type_to_json_schema(type.values)
-          
-          # Create a more descriptive schema for nested structures
-          {
-            type: "object",
-            propertyNames: key_schema,  # Describe key constraints
-            additionalProperties: value_schema,
-            # Add a more explicit description of the expected structure
-            description: "A mapping where keys are #{key_schema[:type]}s and values are #{value_schema[:description] || value_schema[:type]}s"
-          }
-        elsif type.is_a?(T::Types::FixedHash)
-          # Handle fixed hashes (from type aliases like { "key" => Type })
-          properties = {}
-          required = []
-          
-          type.types.each do |key, value_type|
-            properties[key] = type_to_json_schema(value_type)
-            required << key
-          end
-          
-          {
-            type: "object",
-            properties: properties,
-            required: required,
-            additionalProperties: false
-          }
-        elsif type.class.name == "T::Private::Types::SimplePairUnion"
-          # Handle T.nilable types (T::Private::Types::SimplePairUnion)
-          # This is the actual implementation of T.nilable(SomeType)
-          has_nil = type.respond_to?(:types) && type.types.any? do |t| 
-            (t.respond_to?(:raw_type) && t.raw_type == NilClass) ||
-            (t.respond_to?(:name) && t.name == "NilClass")
-          end
-          
-          if has_nil
-            # Find the non-nil type
-            non_nil_type = type.types.find do |t|
-              !(t.respond_to?(:raw_type) && t.raw_type == NilClass) &&
-              !(t.respond_to?(:name) && t.name == "NilClass")
-            end
-            
-            if non_nil_type
-              base_schema = type_to_json_schema(non_nil_type)
-              if base_schema[:type].is_a?(String)
-                # Convert single type to array with null
-                { type: [base_schema[:type], "null"] }.merge(base_schema.except(:type))
-              else
-                # For complex schemas, use anyOf to allow null
-                { anyOf: [base_schema, { type: "null" }] }
-              end
-            else
-              { type: "string" } # Fallback
-            end
-          else
-            # Not nilable SimplePairUnion - this is a regular T.any() union
-            # Generate oneOf schema for all types
-            if type.respond_to?(:types) && type.types.length > 1
-              {
-                oneOf: type.types.map { |t| type_to_json_schema(t) },
-                description: "Union of multiple types"
-              }
-            else
-              # Single type or fallback
-              first_type = type.respond_to?(:types) ? type.types.first : type
-              type_to_json_schema(first_type)
-            end
-          end
-        elsif type.is_a?(T::Types::Union)
-          # Check if this is a nilable type (contains NilClass)
-          is_nilable = type.types.any? { |t| t == T::Utils.coerce(NilClass) }
-          non_nil_types = type.types.reject { |t| t == T::Utils.coerce(NilClass) }
-          
-          # Special case: check if we have TrueClass + FalseClass (T.nilable(T::Boolean))
-          if non_nil_types.size == 2 && is_nilable
-            true_class_type = non_nil_types.find { |t| t.respond_to?(:raw_type) && t.raw_type == TrueClass }
-            false_class_type = non_nil_types.find { |t| t.respond_to?(:raw_type) && t.raw_type == FalseClass }
-            
-            if true_class_type && false_class_type
-              # This is T.nilable(T::Boolean) - treat as nilable boolean
-              return { type: ["boolean", "null"] }
-            end
-          end
-          
-          if non_nil_types.size == 1 && is_nilable
-            # This is T.nilable(SomeType) - generate proper schema with null allowed
-            base_schema = type_to_json_schema(non_nil_types.first)
-            if base_schema[:type].is_a?(String)
-              # Convert single type to array with null
-              { type: [base_schema[:type], "null"] }.merge(base_schema.except(:type))
-            else
-              # For complex schemas, use anyOf to allow null
-              { anyOf: [base_schema, { type: "null" }] }
-            end
-          elsif non_nil_types.size == 1
-            # Non-nilable single type union (shouldn't happen in practice)
-            type_to_json_schema(non_nil_types.first)
-          elsif non_nil_types.size > 1
-            # Handle complex unions with oneOf for better JSON schema compliance
-            base_schema = {
-              oneOf: non_nil_types.map { |t| type_to_json_schema(t) },
-              description: "Union of multiple types"
-            }
-            if is_nilable
-              # Add null as an option for complex nilable unions
-              base_schema[:oneOf] << { type: "null" }
-            end
-            base_schema
-          else
-            { type: "string" }  # Fallback for complex unions
-          end
-        elsif type.is_a?(T::Types::ClassOf)
-          # Handle T.class_of() types
-          {
-            type: "string",
-            description: "Class name (T.class_of type)"
-          }
-        else
-          { type: "string" }  # Default fallback
-        end
-      end
-
-      private
-
-      # Generate JSON schema for custom T::Struct classes
-      sig { params(struct_class: T.class_of(T::Struct)).returns(T::Hash[Symbol, T.untyped]) }
-      def generate_struct_schema(struct_class)
-        return { type: "string", description: "Struct (schema introspection not available)" } unless struct_class.respond_to?(:props)
-
-        properties = {}
-        required = []
-
-        # Check if struct already has a _type field
-        if struct_class.props.key?(:_type)
-          raise DSPy::ValidationError, "_type field conflict: #{struct_class.name} already has a _type field defined. " \
-                                       "DSPy uses _type for automatic type detection in union types."
-        end
-
-        # Add automatic _type field for type detection
-        properties[:_type] = {
-          type: "string",
-          const: struct_class.name.split('::').last  # Use the simple class name
-        }
-        required << "_type"
-
-        struct_class.props.each do |prop_name, prop_info|
-          prop_type = prop_info[:type_object] || prop_info[:type]
-          properties[prop_name] = type_to_json_schema(prop_type)
-          
-          # A field is required if it's not fully optional
-          # fully_optional is true for nilable prop fields
-          # immutable const fields are required unless nilable
-          unless prop_info[:fully_optional]
-            required << prop_name.to_s
-          end
-        end
-
-        {
-          type: "object",
-          properties: properties,
-          required: required,
-          description: "#{struct_class.name} struct"
-        }
-      end
     end
   end
 end

data/lib/dspy/type_system/sorbet_json_schema.rb

@@ -12,8 +12,10 @@ module DSPy
       extend T::Helpers
 
       # Convert a Sorbet type to JSON Schema format
-      sig { params(type: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
-      def self.type_to_json_schema(type)
+      sig { params(type: T.untyped, visited: T.nilable(T::Set[T.untyped])).returns(T::Hash[Symbol, T.untyped]) }
+      def self.type_to_json_schema(type, visited = nil)
+        visited ||= Set.new
+        
         # Handle T::Boolean type alias first
         if type == T::Boolean
           return { type: "boolean" }
@@ -21,7 +23,7 @@ module DSPy
 
         # Handle type aliases by resolving to their underlying type
         if type.is_a?(T::Private::Types::TypeAlias)
-          return self.type_to_json_schema(type.aliased_type)
+          return self.type_to_json_schema(type.aliased_type, visited)
         end
 
         # Handle raw class types first
@@ -38,11 +40,26 @@ module DSPy
             { type: "number" }
           elsif type == Numeric
             { type: "number" }
+          elsif type == Date
+            { type: "string", format: "date" }
+          elsif type == DateTime
+            { type: "string", format: "date-time" }
+          elsif type == Time
+            { type: "string", format: "date-time" }
           elsif [TrueClass, FalseClass].include?(type)
             { type: "boolean" }
           elsif type < T::Struct
             # Handle custom T::Struct classes by generating nested object schema
-            self.generate_struct_schema(type)
+            # Check for recursion
+            if visited.include?(type)
+              # Return a reference to avoid infinite recursion
+              {
+                "$ref" => "#/definitions/#{type.name.split('::').last}",
+                description: "Recursive reference to #{type.name}"
+              }
+            else
+              self.generate_struct_schema(type, visited)
+            end
           else
             { type: "string" }  # Default fallback
           end
@@ -56,6 +73,12 @@ module DSPy
             { type: "number" }
           when "Numeric"
             { type: "number" }
+          when "Date"
+            { type: "string", format: "date" }
+          when "DateTime"
+            { type: "string", format: "date-time" }
+          when "Time"
+            { type: "string", format: "date-time" }
           when "TrueClass", "FalseClass"
             { type: "boolean" }
           when "T::Boolean"
@@ -68,7 +91,14 @@ module DSPy
               { type: "string", enum: values }
             elsif type.raw_type < T::Struct
               # Handle custom T::Struct classes
-              generate_struct_schema(type.raw_type)
+              if visited.include?(type.raw_type)
+                {
+                  "$ref" => "#/definitions/#{type.raw_type.name.split('::').last}",
+                  description: "Recursive reference to #{type.raw_type.name}"
+                }
+              else
+                generate_struct_schema(type.raw_type, visited)
+              end
             else
               { type: "string" }  # Default fallback
             end
@@ -77,13 +107,13 @@ module DSPy
           # Handle arrays properly with nested item type
           {
             type: "array",
-            items: self.type_to_json_schema(type.type)
+            items: self.type_to_json_schema(type.type, visited)
           }
         elsif type.is_a?(T::Types::TypedHash)
           # Handle hashes as objects with additionalProperties
           # TypedHash has keys and values methods to access its key and value types
-          key_schema = self.type_to_json_schema(type.keys)
-          value_schema = self.type_to_json_schema(type.values)
+          key_schema = self.type_to_json_schema(type.keys, visited)
+          value_schema = self.type_to_json_schema(type.values, visited)
           
           # Create a more descriptive schema for nested structures
           {
@@ -99,7 +129,7 @@ module DSPy
           required = []
           
           type.types.each do |key, value_type|
-            properties[key] = self.type_to_json_schema(value_type)
+            properties[key] = self.type_to_json_schema(value_type, visited)
             required << key
           end
           
@@ -125,7 +155,7 @@ module DSPy
             end
             
             if non_nil_type
-              base_schema = self.type_to_json_schema(non_nil_type)
+              base_schema = self.type_to_json_schema(non_nil_type, visited)
               if base_schema[:type].is_a?(String)
                 # Convert single type to array with null
                 { type: [base_schema[:type], "null"] }.merge(base_schema.except(:type))
@@ -141,13 +171,13 @@ module DSPy
             # Generate oneOf schema for all types
             if type.respond_to?(:types) && type.types.length > 1
               {
-                oneOf: type.types.map { |t| self.type_to_json_schema(t) },
+                oneOf: type.types.map { |t| self.type_to_json_schema(t, visited) },
                 description: "Union of multiple types"
               }
             else
               # Single type or fallback
               first_type = type.respond_to?(:types) ? type.types.first : type
-              self.type_to_json_schema(first_type)
+              self.type_to_json_schema(first_type, visited)
             end
           end
         elsif type.is_a?(T::Types::Union)
@@ -168,7 +198,7 @@ module DSPy
           
           if non_nil_types.size == 1 && is_nilable
             # This is T.nilable(SomeType) - generate proper schema with null allowed
-            base_schema = self.type_to_json_schema(non_nil_types.first)
+            base_schema = self.type_to_json_schema(non_nil_types.first, visited)
             if base_schema[:type].is_a?(String)
               # Convert single type to array with null
               { type: [base_schema[:type], "null"] }.merge(base_schema.except(:type))
@@ -178,11 +208,11 @@ module DSPy
             end
           elsif non_nil_types.size == 1
             # Non-nilable single type union (shouldn't happen in practice)
-            self.type_to_json_schema(non_nil_types.first)
+            self.type_to_json_schema(non_nil_types.first, visited)
           elsif non_nil_types.size > 1
             # Handle complex unions with oneOf for better JSON schema compliance
             base_schema = {
-              oneOf: non_nil_types.map { |t| self.type_to_json_schema(t) },
+              oneOf: non_nil_types.map { |t| self.type_to_json_schema(t, visited) },
               description: "Union of multiple types"
             }
             if is_nilable
@@ -205,10 +235,15 @@ module DSPy
       end
 
       # Generate JSON schema for custom T::Struct classes
-      sig { params(struct_class: T.class_of(T::Struct)).returns(T::Hash[Symbol, T.untyped]) }
-      def self.generate_struct_schema(struct_class)
+      sig { params(struct_class: T.class_of(T::Struct), visited: T.nilable(T::Set[T.untyped])).returns(T::Hash[Symbol, T.untyped]) }
+      def self.generate_struct_schema(struct_class, visited = nil)
+        visited ||= Set.new
+        
         return { type: "string", description: "Struct (schema introspection not available)" } unless struct_class.respond_to?(:props)
 
+        # Add this struct to visited set to detect recursion
+        visited.add(struct_class)
+
         properties = {}
         required = []
 
@@ -227,7 +262,7 @@ module DSPy
 
         struct_class.props.each do |prop_name, prop_info|
           prop_type = prop_info[:type_object] || prop_info[:type]
-          properties[prop_name] = self.type_to_json_schema(prop_type)
+          properties[prop_name] = self.type_to_json_schema(prop_type, visited)
           
           # A field is required if it's not fully optional
           # fully_optional is true for nilable prop fields
@@ -237,6 +272,9 @@ module DSPy
           end
         end
 
+        # Remove this struct from visited set after processing
+        visited.delete(struct_class)
+
         {
           type: "object",
           properties: properties,

data/lib/dspy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DSPy
-  VERSION = "0.27.4"
+  VERSION = "0.27.6"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.27.4
+  version: 0.27.6
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
 bindir: bin
 cert_chain: []
-date: 2025-09-25 00:00:00.000000000 Z
+date: 2025-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable