dspy 0.27.5 → 0.28.0

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/tools/base.rb

@@ -145,11 +145,11 @@ module DSPy
                 when String
                   begin
                     JSON.parse(args_json)
-                  rescue JSON::ParserError
-                    return "Error: Invalid JSON input"
+                  rescue JSON::ParserError => e
+                    raise ArgumentError, "Invalid JSON input: #{e.message}"
                   end
                 else
-                  return "Error: Expected Hash or JSON string"
+                  raise ArgumentError, "Expected Hash or JSON string, got #{args_json.class}"
                 end
 
           # Convert string keys to symbols and validate types
@@ -168,7 +168,7 @@ module DSPy
               if args.key?(key)
                 kwargs[param_name] = coerce_value_to_type(args[key], param_type)
               elsif schema[:required].include?(key)
-                return "Error: Missing required parameter: #{key}"
+                raise ArgumentError, "Missing required parameter: #{key}"
               end
             end
             
@@ -180,15 +180,13 @@ module DSPy
               if args.key?(key)
                 kwargs[param_name] = coerce_value_to_type(args[key], param_type)
               elsif schema[:required].include?(key)
-                return "Error: Missing required parameter: #{key}"
+                raise ArgumentError, "Missing required parameter: #{key}"
               end
             end
           end
 
           call(**kwargs)
         end
-      rescue => e
-        "Error: #{e.message}"
       end
 
       # Subclasses must implement their own call method with their own signature

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.5"
+  VERSION = "0.28.0"
 end

data/lib/dspy.rb

@@ -23,15 +23,8 @@ module DSPy
   setting :structured_outputs do
     setting :openai, default: false
     setting :anthropic, default: false  # Reserved for future use
-    setting :strategy, default: nil  # Can be DSPy::Strategy::Strict, DSPy::Strategy::Compatible, or nil for auto
-    setting :retry_enabled, default: true
-    setting :max_retries, default: 3
-    setting :fallback_enabled, default: true
   end
 
-  # Test mode disables sleeps in retry logic
-  setting :test_mode, default: false
-
   def self.logger
     @logger ||= create_logger
   end
@@ -206,7 +199,6 @@ require_relative 'dspy/prompt'
 require_relative 'dspy/example'
 require_relative 'dspy/lm'
 require_relative 'dspy/image'
-require_relative 'dspy/strategy'
 require_relative 'dspy/prediction'
 require_relative 'dspy/predict'
 require_relative 'dspy/events/subscribers'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.27.5
+  version: 0.28.0
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
 bindir: bin
 cert_chain: []
-date: 2025-09-30 00:00:00.000000000 Z
+date: 2025-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -213,19 +213,12 @@ files:
 - lib/dspy/lm/adapters/openai/schema_converter.rb
 - lib/dspy/lm/adapters/openai_adapter.rb
 - lib/dspy/lm/adapters/openrouter_adapter.rb
+- lib/dspy/lm/chat_strategy.rb
 - lib/dspy/lm/errors.rb
+- lib/dspy/lm/json_strategy.rb
 - lib/dspy/lm/message.rb
 - lib/dspy/lm/message_builder.rb
 - lib/dspy/lm/response.rb
-- lib/dspy/lm/retry_handler.rb
-- lib/dspy/lm/strategies/anthropic_extraction_strategy.rb
-- lib/dspy/lm/strategies/anthropic_tool_use_strategy.rb
-- lib/dspy/lm/strategies/base_strategy.rb
-- lib/dspy/lm/strategies/enhanced_prompting_strategy.rb
-- lib/dspy/lm/strategies/gemini_structured_output_strategy.rb
-- lib/dspy/lm/strategies/openai_structured_output_strategy.rb
-- lib/dspy/lm/strategy_selector.rb
-- lib/dspy/lm/structured_output_strategy.rb
 - lib/dspy/lm/usage.rb
 - lib/dspy/lm/vision_models.rb
 - lib/dspy/memory.rb
@@ -254,7 +247,6 @@ files:
 - lib/dspy/signature.rb
 - lib/dspy/storage/program_storage.rb
 - lib/dspy/storage/storage_manager.rb
-- lib/dspy/strategy.rb
 - lib/dspy/teleprompt/data_handler.rb
 - lib/dspy/teleprompt/gepa.rb
 - lib/dspy/teleprompt/mipro_v2.rb