dspy 0.19.1 → 0.20.1

data/lib/dspy/teleprompt/mipro_v2.rb

@@ -18,8 +18,13 @@ module DSPy
       module AutoMode
         extend T::Sig
 
-        sig { returns(MIPROv2) }
-        def self.light
+        sig do
+          params(
+            metric: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T.untyped)),
+            kwargs: T.untyped
+          ).returns(MIPROv2)
+        end
+        def self.light(metric: nil, **kwargs)
           config = MIPROv2Config.new
           config.num_trials = 6
           config.num_instruction_candidates = 3
@@ -28,11 +33,16 @@ module DSPy
           config.bootstrap_sets = 3
           config.optimization_strategy = "greedy"
           config.early_stopping_patience = 2
-          MIPROv2.new(config: config)
+          MIPROv2.new(metric: metric, config: config, **kwargs)
         end
 
-        sig { returns(MIPROv2) }
-        def self.medium
+        sig do
+          params(
+            metric: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T.untyped)),
+            kwargs: T.untyped
+          ).returns(MIPROv2)
+        end
+        def self.medium(metric: nil, **kwargs)
           config = MIPROv2Config.new
           config.num_trials = 12
           config.num_instruction_candidates = 5
@@ -41,11 +51,16 @@ module DSPy
           config.bootstrap_sets = 5
           config.optimization_strategy = "adaptive"
           config.early_stopping_patience = 3
-          MIPROv2.new(config: config)
+          MIPROv2.new(metric: metric, config: config, **kwargs)
         end
 
-        sig { returns(MIPROv2) }
-        def self.heavy
+        sig do
+          params(
+            metric: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T.untyped)),
+            kwargs: T.untyped
+          ).returns(MIPROv2)
+        end
+        def self.heavy(metric: nil, **kwargs)
           config = MIPROv2Config.new
           config.num_trials = 18
           config.num_instruction_candidates = 8
@@ -54,7 +69,7 @@ module DSPy
           config.bootstrap_sets = 8
           config.optimization_strategy = "bayesian"
           config.early_stopping_patience = 5
-          MIPROv2.new(config: config)
+          MIPROv2.new(metric: metric, config: config, **kwargs)
         end
       end
 
@@ -188,6 +203,9 @@ module DSPy
         sig { returns(T::Hash[Symbol, T.untyped]) }
         attr_reader :proposal_statistics
 
+        sig { returns(T.nilable(DSPy::Evaluate::BatchEvaluationResult)) }
+        attr_reader :best_evaluation_result
+
         sig do
           params(
             optimized_program: T.untyped,
@@ -199,10 +217,11 @@ module DSPy
             proposal_statistics: T::Hash[Symbol, T.untyped],
             best_score_name: T.nilable(String),
             best_score_value: T.nilable(Float),
-            metadata: T::Hash[Symbol, T.untyped]
+            metadata: T::Hash[Symbol, T.untyped],
+            best_evaluation_result: T.nilable(DSPy::Evaluate::BatchEvaluationResult)
           ).void
         end
-        def initialize(optimized_program:, scores:, history:, evaluated_candidates:, optimization_trace:, bootstrap_statistics:, proposal_statistics:, best_score_name: nil, best_score_value: nil, metadata: {})
+        def initialize(optimized_program:, scores:, history:, evaluated_candidates:, optimization_trace:, bootstrap_statistics:, proposal_statistics:, best_score_name: nil, best_score_value: nil, metadata: {}, best_evaluation_result: nil)
           super(
             optimized_program: optimized_program,
             scores: scores,
@@ -215,6 +234,7 @@ module DSPy
           @optimization_trace = optimization_trace.freeze
           @bootstrap_statistics = bootstrap_statistics.freeze
           @proposal_statistics = proposal_statistics.freeze
+          @best_evaluation_result = best_evaluation_result&.freeze
         end
 
         sig { returns(T::Hash[Symbol, T.untyped]) }
@@ -223,7 +243,8 @@ module DSPy
             evaluated_candidates: @evaluated_candidates.map(&:to_h),
             optimization_trace: @optimization_trace,
             bootstrap_statistics: @bootstrap_statistics,
-            proposal_statistics: @proposal_statistics
+            proposal_statistics: @proposal_statistics,
+            best_evaluation_result: @best_evaluation_result&.to_h
           })
         end
       end
@@ -384,6 +405,7 @@ module DSPy
         best_score = 0.0
         best_candidate = nil
         best_program = nil
+        best_evaluation_result = nil
         
         @mipro_config.num_trials.times do |trial_idx|
           trials_completed = trial_idx + 1
@@ -400,7 +422,7 @@ module DSPy
 
           begin
             # Evaluate candidate
-            score, modified_program = evaluate_candidate(program, candidate, evaluation_set)
+            score, modified_program, evaluation_result = evaluate_candidate(program, candidate, evaluation_set)
             
             # Update optimization state
             update_optimization_state(optimization_state, candidate, score)
@@ -411,6 +433,7 @@ module DSPy
               best_score = score
               best_candidate = candidate
               best_program = modified_program
+              best_evaluation_result = evaluation_result
             end
 
             emit_event('trial_complete', {
@@ -441,6 +464,7 @@ module DSPy
           best_score: best_score,
           best_candidate: best_candidate,
           best_program: best_program,
+          best_evaluation_result: best_evaluation_result,
           trials_completed: trials_completed,
           optimization_state: optimization_state,
           evaluated_candidates: @evaluated_candidates
@@ -611,7 +635,7 @@ module DSPy
           program: T.untyped,
           candidate: CandidateConfig,
           evaluation_set: T::Array[DSPy::Example]
-        ).returns([Float, T.untyped])
+        ).returns([Float, T.untyped, DSPy::Evaluate::BatchEvaluationResult])
       end
       def evaluate_candidate(program, candidate, evaluation_set)
         # Apply candidate configuration to program
@@ -623,7 +647,7 @@ module DSPy
         # Store evaluation details
         @evaluated_candidates << candidate
         
-        [evaluation_result.pass_rate, modified_program]
+        [evaluation_result.pass_rate, modified_program, evaluation_result]
       end
 
       # Apply candidate configuration to program
@@ -709,6 +733,7 @@ module DSPy
         best_candidate = optimization_result[:best_candidate]
         best_program = optimization_result[:best_program]
         best_score = optimization_result[:best_score]
+        best_evaluation_result = optimization_result[:best_evaluation_result]
         
         scores = { pass_rate: best_score }
         
@@ -736,12 +761,28 @@ module DSPy
           best_score_value: best_score,
           metadata: metadata,
           evaluated_candidates: @evaluated_candidates,
-          optimization_trace: optimization_result[:optimization_state] || {},
+          optimization_trace: serialize_optimization_trace(optimization_result[:optimization_state]),
           bootstrap_statistics: bootstrap_result.statistics,
-          proposal_statistics: proposal_result.analysis
+          proposal_statistics: proposal_result.analysis,
+          best_evaluation_result: best_evaluation_result
         )
       end
 
+      # Serialize optimization trace for better JSON output
+      sig { params(optimization_state: T.nilable(T::Hash[Symbol, T.untyped])).returns(T::Hash[Symbol, T.untyped]) }
+      def serialize_optimization_trace(optimization_state)
+        return {} unless optimization_state
+        
+        serialized_trace = optimization_state.dup
+        
+        # Convert candidate objects to their hash representations
+        if serialized_trace[:candidates]
+          serialized_trace[:candidates] = serialized_trace[:candidates].map(&:to_h)
+        end
+        
+        serialized_trace
+      end
+
       # Helper methods
       sig { params(program: T.untyped).returns(T.nilable(String)) }
       def extract_current_instruction(program)

data/lib/dspy/teleprompt/utils.rb

@@ -247,15 +247,17 @@ module DSPy
             prediction = program.call(**example.input_values)
             
             # Check if prediction matches expected output
+            prediction_hash = extract_output_fields_from_prediction(prediction, example.signature_class)
+            
             if metric
-              success = metric.call(example, prediction.to_h)
+              success = metric.call(example, prediction_hash)
             else
-              success = example.matches_prediction?(prediction.to_h)
+              success = example.matches_prediction?(prediction_hash)
             end
 
             if success
               # Create a new example with the successful prediction as reasoning/context
-              successful_example = create_successful_bootstrap_example(example, prediction)
+              successful_example = create_successful_bootstrap_example(example, prediction_hash)
               successful << successful_example
               
               emit_bootstrap_example_event(index, true, nil)
@@ -311,7 +313,7 @@ module DSPy
       sig do
         params(
           original_example: DSPy::Example,
-          prediction: T.untyped
+          prediction: T::Hash[Symbol, T.untyped]
         ).returns(DSPy::Example)
       end
       def self.create_successful_bootstrap_example(original_example, prediction)
@@ -319,7 +321,7 @@ module DSPy
         DSPy::Example.new(
           signature_class: original_example.signature_class,
           input: original_example.input_values,
-          expected: prediction.to_h,
+          expected: prediction,
           id: "bootstrap_#{original_example.id || SecureRandom.uuid}",
           metadata: {
             source: "bootstrap",
@@ -329,6 +331,29 @@ module DSPy
         )
       end
 
+      # Extract only output fields from prediction (exclude input fields)
+      sig do
+        params(
+          prediction: T.untyped,
+          signature_class: T.class_of(DSPy::Signature)
+        ).returns(T::Hash[Symbol, T.untyped])
+      end
+      def self.extract_output_fields_from_prediction(prediction, signature_class)
+        prediction_hash = prediction.to_h
+        
+        # Get output field names from signature
+        output_fields = signature_class.output_field_descriptors.keys
+        
+        # Filter prediction to only include output fields
+        filtered_expected = {}
+        output_fields.each do |field_name|
+          if prediction_hash.key?(field_name)
+            filtered_expected[field_name] = prediction_hash[field_name]
+          end
+        end
+        
+        filtered_expected
+      end
 
       # Create default metric for examples
       sig { params(examples: T::Array[T.untyped]).returns(T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T::Boolean))) }

data/lib/dspy/version.rb

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

data/lib/dspy.rb

@@ -74,6 +74,20 @@ module DSPy
     end
   end
 
+  # Fiber-local LM context for temporary model overrides
+  FIBER_LM_KEY = :dspy_fiber_lm
+
+  def self.current_lm
+    Fiber[FIBER_LM_KEY] || config.lm
+  end
+
+  def self.with_lm(lm)
+    previous_lm = Fiber[FIBER_LM_KEY]
+    Fiber[FIBER_LM_KEY] = lm
+    yield
+  ensure
+    Fiber[FIBER_LM_KEY] = previous_lm
+  end
 end
 
 require_relative 'dspy/module'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.19.1
+  version: 0.20.1
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
 bindir: bin
 cert_chain: []
-date: 2025-08-11 00:00:00.000000000 Z
+date: 2025-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -79,6 +79,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: gemini-ai
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.3'
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -186,6 +200,7 @@ files:
 - lib/dspy/lm/adapter.rb
 - lib/dspy/lm/adapter_factory.rb
 - lib/dspy/lm/adapters/anthropic_adapter.rb
+- lib/dspy/lm/adapters/gemini_adapter.rb
 - lib/dspy/lm/adapters/ollama_adapter.rb
 - lib/dspy/lm/adapters/openai/schema_converter.rb
 - lib/dspy/lm/adapters/openai_adapter.rb