dspy 0.29.0 → 0.30.0

data/lib/dspy/teleprompt/teleprompter.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'sorbet-runtime'
-require_relative '../evaluate'
+require_relative '../evals'
 require_relative '../example'
 
 module DSPy
@@ -125,7 +125,7 @@ module DSPy
       sig { returns(T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T.untyped))) }
       attr_reader :metric
 
-      sig { returns(T.nilable(DSPy::Evaluate)) }
+      sig { returns(T.nilable(DSPy::Evals)) }
       attr_reader :evaluator
 
       sig do
@@ -183,12 +183,12 @@ module DSPy
       end
 
       # Create evaluator for given examples and metric
-      sig { params(examples: T::Array[T.untyped]).returns(DSPy::Evaluate) }
+      sig { params(examples: T::Array[T.untyped]).returns(DSPy::Evals) }
       def create_evaluator(examples)
         # Use provided metric or create a default one for DSPy::Example objects
         evaluation_metric = @metric || default_metric_for_examples(examples)
         
-        @evaluator = DSPy::Evaluate.new(
+        @evaluator = DSPy::Evals.new(
           nil, # Program will be set during evaluation
           metric: evaluation_metric,
           num_threads: @config.num_threads,
@@ -202,12 +202,12 @@ module DSPy
           program: T.untyped,
           examples: T::Array[T.untyped],
           metric: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T.untyped))
-        ).returns(DSPy::Evaluate::BatchEvaluationResult)
+        ).returns(DSPy::Evals::BatchEvaluationResult)
       end
       def evaluate_program(program, examples, metric: nil)
         evaluation_metric = metric || @metric || default_metric_for_examples(examples)
         
-        evaluator = DSPy::Evaluate.new(
+        evaluator = DSPy::Evals.new(
           program,
           metric: evaluation_metric,
           num_threads: @config.num_threads,

data/lib/dspy/teleprompt/utils.rb

@@ -2,7 +2,7 @@
 
 require 'sorbet-runtime'
 require 'fileutils'
-require_relative '../evaluate'
+require_relative '../evals'
 require_relative '../example'
 require_relative 'data_handler'
 
@@ -13,66 +13,6 @@ module DSPy
     module Utils
       extend T::Sig
 
-      # Wrapper class that provides Python-compatible signature API
-      # Wraps a Predict instance to provide signature access and modification
-      class SignatureWrapper
-        extend T::Sig
-
-        sig { returns(T.untyped) }
-        attr_reader :predictor
-
-        sig { params(predictor: T.untyped).void }
-        def initialize(predictor)
-          @predictor = predictor
-        end
-
-        sig { returns(String) }
-        def instructions
-          # Get instructions from the predictor's prompt
-          @predictor.prompt.instruction
-        end
-
-        sig { params(new_instructions: String).returns(SignatureWrapper) }
-        def with_instructions(new_instructions)
-          # Return a new wrapper that will apply new instructions when set
-          updated_wrapper = SignatureWrapper.new(@predictor)
-          updated_wrapper.instance_variable_set(:@pending_instructions, new_instructions)
-          updated_wrapper
-        end
-
-        sig { returns(T.nilable(String)) }
-        def pending_instructions
-          @pending_instructions
-        end
-      end
-
-      # Get signature information from a predictor (Python compatibility)
-      # Returns a wrapper that provides Python-like signature API
-      #
-      # @param predictor [Predict] The predictor to get signature from
-      # @return [SignatureWrapper] Wrapper providing signature access
-      sig { params(predictor: T.untyped).returns(SignatureWrapper) }
-      def self.get_signature(predictor)
-        SignatureWrapper.new(predictor)
-      end
-
-      # Set signature on a predictor (Python compatibility)
-      # Updates the predictor's prompt with new instructions
-      #
-      # @param predictor [Predict] The predictor to update
-      # @param updated_signature [SignatureWrapper] The updated signature wrapper
-      sig { params(predictor: T.untyped, updated_signature: SignatureWrapper).void }
-      def self.set_signature(predictor, updated_signature)
-        # Extract pending instructions from the wrapper
-        new_instructions = updated_signature.pending_instructions
-
-        if new_instructions
-          # Update the predictor's prompt with new instructions
-          # We mutate the prompt's instruction directly for MIPROv2 compatibility
-          predictor.prompt.instance_variable_set(:@instruction, new_instructions)
-        end
-      end
-
       # Create a minibatch from the trainset using random sampling
       # This function is compatible with Python DSPy's MIPROv2 implementation
       #
@@ -459,7 +399,7 @@ module DSPy
           examples: T::Array[T.untyped],
           config: BootstrapConfig,
           metric: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean))
-        ).returns(DSPy::Evaluate::BatchEvaluationResult)
+        ).returns(DSPy::Evals::BatchEvaluationResult)
       end
       def self.eval_candidate_program(program, examples, config: BootstrapConfig.new, metric: nil)
         # Use minibatch evaluation for large datasets
@@ -477,7 +417,7 @@ module DSPy
           examples: T::Array[T.untyped],
           config: BootstrapConfig,
           metric: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean))
-        ).returns(DSPy::Evaluate::BatchEvaluationResult)
+        ).returns(DSPy::Evals::BatchEvaluationResult)
       end
       def self.eval_candidate_program_minibatch(program, examples, config, metric)
         DSPy::Context.with_span(
@@ -502,11 +442,11 @@ module DSPy
           examples: T::Array[T.untyped],
           config: BootstrapConfig,
           metric: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean))
-        ).returns(DSPy::Evaluate::BatchEvaluationResult)
+        ).returns(DSPy::Evals::BatchEvaluationResult)
       end
       def self.eval_candidate_program_full(program, examples, config, metric)
         # Create evaluator with proper configuration
-        evaluator = DSPy::Evaluate.new(
+        evaluator = DSPy::Evals.new(
           program,
           metric: metric || default_metric_for_examples(examples),
           num_threads: config.num_threads,

data/lib/dspy/type_system/sorbet_json_schema.rb

@@ -1,301 +1,4 @@
-# typed: strict
+# typed: false
 # frozen_string_literal: true
 
-require 'sorbet-runtime'
-
-module DSPy
-  module TypeSystem
-    # Unified module for converting Sorbet types to JSON Schema
-    # Extracted from Signature class to ensure consistency across Tools, Toolsets, and Signatures
-    module SorbetJsonSchema
-      extend T::Sig
-      extend T::Helpers
-
-      # Convert a Sorbet type to JSON Schema format
-      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" }
-        end
-
-        # 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, visited)
-        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
-            # 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
-        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
-              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
-          end
-        elsif type.is_a?(T::Types::TypedArray)
-          # Handle arrays properly with nested item type
-          {
-            type: "array",
-            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, visited)
-          value_schema = self.type_to_json_schema(type.values, visited)
-          
-          # 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] = self.type_to_json_schema(value_type, visited)
-            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 = 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))
-              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| 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, visited)
-            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 = 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))
-            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)
-            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, visited) },
-              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
-
-      # Generate JSON schema for custom T::Struct classes
-      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 = []
-
-        # 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] = 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
-          # immutable const fields are required unless nilable
-          unless prop_info[:fully_optional]
-            required << prop_name.to_s
-          end
-        end
-
-        # Remove this struct from visited set after processing
-        visited.delete(struct_class)
-
-        {
-          type: "object",
-          properties: properties,
-          required: required,
-          description: "#{struct_class.name} struct"
-        }
-      end
-
-      private
-
-      # Extensions to Hash for Rails-like except method if not available
-      # This ensures compatibility with the original code
-      unless Hash.method_defined?(:except)
-        Hash.class_eval do
-          def except(*keys)
-            dup.tap do |hash|
-              keys.each { |key| hash.delete(key) }
-            end
-          end
-        end
-      end
-    end
-  end
-end
+require 'dspy/schema'

data/lib/dspy/version.rb

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

data/lib/dspy.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require_relative 'dspy/support/warning_filters'
 require 'sorbet-runtime'
 require 'dry-configurable'
 require 'dry/logger'
@@ -8,7 +9,6 @@ require_relative 'dspy/version'
 require_relative 'dspy/errors'
 require_relative 'dspy/type_serializer'
 require_relative 'dspy/observability'
-require_relative 'dspy/observability/observation_type'
 require_relative 'dspy/context'
 require_relative 'dspy/events'
 require_relative 'dspy/events/types'
@@ -30,6 +30,10 @@ module DSPy
     @logger ||= create_logger
   end
 
+  # Writes structured output to the configured logger. Use this for human-readable
+  # logs only—listeners and telemetry exporters are not triggered by `DSPy.log`.
+  # Prefer `DSPy.event` whenever you want consumers (or Langfuse/OpenTelemetry)
+  # to react to what happened.
   def self.log(event_name, **attributes)
     # Return nil early if logger is not configured (backward compatibility)
     return nil unless logger
@@ -41,6 +45,10 @@ module DSPy
     nil
   end
 
+  # Emits a structured event that flows through DSPy's event bus, fires any
+  # subscribed listeners, and creates OpenTelemetry spans when observability
+  # is enabled. Use this for anything that should be tracked, instrumented,
+  # or forwarded to Langfuse.
   def self.event(event_name_or_object, attributes = {})
     # Handle typed event objects
     if event_name_or_object.respond_to?(:name) && event_name_or_object.respond_to?(:to_attributes)
@@ -108,7 +116,8 @@ module DSPy
     'observability.error',
     'observability.span_error',
     'observability.span_finish_error',
-    'event.span_creation_error'
+    'event.span_creation_error',
+    'lm.tokens'
   ].freeze
 
   def self.create_event_span(event_name, attributes)
@@ -199,7 +208,6 @@ require_relative 'dspy/signature'
 require_relative 'dspy/few_shot_example'
 require_relative 'dspy/prompt'
 require_relative 'dspy/example'
-require_relative 'dspy/datasets'
 require_relative 'dspy/lm'
 require_relative 'dspy/image'
 require_relative 'dspy/prediction'
@@ -208,16 +216,34 @@ require_relative 'dspy/events/subscribers'
 require_relative 'dspy/events/subscriber_mixin'
 require_relative 'dspy/chain_of_thought'
 require_relative 'dspy/re_act'
-require_relative 'dspy/code_act'
-require_relative 'dspy/evaluate'
+require_relative 'dspy/evals'
 require_relative 'dspy/teleprompt/teleprompter'
 require_relative 'dspy/teleprompt/utils'
 require_relative 'dspy/teleprompt/data_handler'
-require_relative 'dspy/teleprompt/gepa'
 require_relative 'dspy/propose/grounded_proposer'
-require_relative 'dspy/teleprompt/mipro_v2'
+begin
+  require 'dspy/o11y/langfuse'
+rescue LoadError
+end
+begin
+  require 'dspy/gepa'
+rescue LoadError
+end
+begin
+  require 'dspy/code_act'
+rescue LoadError
+end
+begin
+  require 'dspy/miprov2'
+rescue LoadError
+end
 require_relative 'dspy/tools'
 require_relative 'dspy/memory'
+
+begin
+  require 'dspy/datasets'
+rescue LoadError
+end
 require_relative 'dspy/storage/program_storage'
 require_relative 'dspy/storage/storage_manager'
 require_relative 'dspy/registry/signature_registry'