dspy 0.26.0 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 573bfc89c0ca4d6c58a3d68fa96e0b0e8fc1d8bc2c38eec9c67e245a51527532
-  data.tar.gz: a2b34e8127abafbdec6842c3db475e1abbfbcf06c0ca9bfcd3fa7ea8299d0d0f
+  metadata.gz: 5bb3b493e5411fd1f18028a3177c99149c2507f4d05a100746b2da734daa6a63
+  data.tar.gz: 78d2325d7b28a1b393284ec765c0f9fa3048c60afd864e3fcec0a88aac96cdc7
 SHA512:
-  metadata.gz: 88d9b7c29cf89d386ada79f8696f561b94087458715813b45ce2be18947163e840deabfe681d0f7594023fd09c84c1ff3746c87d19c2ebc8043103f5f98cbdc7
-  data.tar.gz: 5e5d518266d7dafe64abf3f3d6b083c6017feb2564743053c23bf9b6baa5a32be53eab299a57814b70ce05d236e3f5d659158679914ac097fd7fcc589b4ddb04
+  metadata.gz: c11ef22db12b776b0dacb648cc60312aedb398b13020991827b85eca169b319960e8c4f31cc8216c93a766f67ed779998ee22f932bc02cb4ba802ce58c0a4ff4
+  data.tar.gz: 68847a5ef35187be690b82e0bd1b30d4da7988c2bf1da9fd3820e4ae2315c96900f798b4580b1dcd236fa4c4e45a4289c57301b36b1c24564fda020ee174107b

data/README.md

@@ -59,6 +59,25 @@ puts result.sentiment    # => #<Sentiment::Positive>
 puts result.confidence   # => 0.85
 ```
 
+### Alternative Providers
+
+DSPy.rb supports multiple providers with native structured outputs:
+
+```ruby
+# Google Gemini with native structured outputs
+DSPy.configure do |c|
+  c.lm = DSPy::LM.new('gemini/gemini-1.5-flash',
+                      api_key: ENV['GEMINI_API_KEY'], 
+                      structured_outputs: true)  # Supports gemini-1.5-pro, gemini-1.5-flash, gemini-2.0-flash-exp
+end
+
+# Anthropic Claude with tool-based extraction
+DSPy.configure do |c|
+  c.lm = DSPy::LM.new('anthropic/claude-3-sonnet-20241022',
+                      api_key: ENV['ANTHROPIC_API_KEY'])  # Automatic strategy selection
+end
+```
+
 ## What You Get
 
 **Core Building Blocks:**
@@ -77,7 +96,7 @@ puts result.confidence   # => 0.85
 - **GEPA Optimization** - Genetic-Pareto optimization for multi-objective prompt improvement
 
 **Production Features:**
-- **Reliable JSON Extraction** - Native OpenAI structured outputs, Anthropic extraction patterns, and automatic strategy selection with fallback
+- **Reliable JSON Extraction** - Native structured outputs for OpenAI and Gemini, Anthropic tool-based extraction, and automatic strategy selection with fallback
 - **Type-Safe Configuration** - Strategy enums with automatic provider optimization (Strict/Compatible modes)
 - **Smart Retry Logic** - Progressive fallback with exponential backoff for handling transient failures
 - **Zero-Config Langfuse Integration** - Set env vars and get automatic OpenTelemetry traces in Langfuse
@@ -89,6 +108,7 @@ puts result.confidence   # => 0.85
 - LLM provider support using official Ruby clients:
   - [OpenAI Ruby](https://github.com/openai/openai-ruby) with vision model support
   - [Anthropic Ruby SDK](https://github.com/anthropics/anthropic-sdk-ruby) with multimodal capabilities
+  - [Google Gemini API](https://ai.google.dev/) with native structured outputs
   - [Ollama](https://ollama.com/) via OpenAI compatibility layer for local models
 - **Multimodal Support** - Complete image analysis with DSPy::Image, type-safe bounding boxes, vision-capable models
 - Runtime type checking with [Sorbet](https://sorbet.org/) including T::Enum and union types
@@ -157,29 +177,6 @@ Then run:
 bundle install
 ```
 
-#### System Dependencies for Ubuntu/Pop!_OS
-
-If you need to compile the `numo-narray` dependency from source (used for numerical computing in Bayesian optimization), install these system packages:
-
-```bash
-# Update package list
-sudo apt-get update
-
-# Install Ruby development files (if not already installed)
-sudo apt-get install ruby-full ruby-dev
-
-# Install essential build tools
-sudo apt-get install build-essential
-
-# Install BLAS and LAPACK libraries (required for numo-narray)
-sudo apt-get install libopenblas-dev liblapack-dev
-
-# Install additional development libraries
-sudo apt-get install libffi-dev libssl-dev
-```
-
-**Note**: The `numo-narray` gem typically compiles quickly (1-2 minutes). Pre-built binaries are available for most platforms, so compilation is only needed if a pre-built binary isn't available for your system.
-
 ## Recent Achievements
 
 DSPy.rb has rapidly evolved from experimental to production-ready:

data/lib/dspy/lm/adapter_factory.rb

@@ -24,8 +24,8 @@ module DSPy
           
           # Pass provider-specific options
           adapter_options = { model: model, api_key: api_key }
-          # Both OpenAI and Ollama accept additional options
-          adapter_options.merge!(options) if %w[openai ollama].include?(provider)
+          # OpenAI, Ollama, and Gemini accept additional options
+          adapter_options.merge!(options) if %w[openai ollama gemini].include?(provider)
           
           adapter_class.new(**adapter_options)
         end

data/lib/dspy/lm/adapters/gemini/schema_converter.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+require_relative "../../cache_manager"
+
+module DSPy
+  class LM
+    module Adapters
+      module Gemini
+        # Converts DSPy signatures to Gemini structured output format
+        class SchemaConverter
+          extend T::Sig
+
+          # Models that support structured outputs
+          STRUCTURED_OUTPUT_MODELS = T.let([
+            "gemini-1.5-pro",
+            "gemini-1.5-flash",
+            "gemini-2.0-flash-exp"
+          ].freeze, T::Array[String])
+
+          sig { params(signature_class: T.class_of(DSPy::Signature)).returns(T::Hash[Symbol, T.untyped]) }
+          def self.to_gemini_format(signature_class)
+            # Check cache first
+            cache_manager = DSPy::LM.cache_manager
+            cached_schema = cache_manager.get_schema(signature_class, "gemini", {})
+            
+            if cached_schema
+              DSPy.logger.debug("Using cached schema for #{signature_class.name}")
+              return cached_schema
+            end
+            
+            # Get the output JSON schema from the signature class
+            output_schema = signature_class.output_json_schema
+            
+            # Convert to Gemini format (OpenAPI 3.0 Schema subset - not related to OpenAI)
+            gemini_schema = convert_dspy_schema_to_gemini(output_schema)
+            
+            # Cache the result
+            cache_manager.cache_schema(signature_class, "gemini", gemini_schema, {})
+            
+            gemini_schema
+          end
+
+          sig { params(model: String).returns(T::Boolean) }
+          def self.supports_structured_outputs?(model)
+            # Check cache first
+            cache_manager = DSPy::LM.cache_manager
+            cached_result = cache_manager.get_capability(model, "structured_outputs")
+            
+            if !cached_result.nil?
+              DSPy.logger.debug("Using cached capability check for #{model}")
+              return cached_result
+            end
+            
+            # Extract base model name without provider prefix
+            base_model = model.sub(/^gemini\//, "")
+            
+            # Check if it's a supported model or a newer version
+            result = STRUCTURED_OUTPUT_MODELS.any? { |supported| base_model.start_with?(supported) }
+            
+            # Cache the result
+            cache_manager.cache_capability(model, "structured_outputs", result)
+            
+            result
+          end
+
+          sig { params(schema: T::Hash[Symbol, T.untyped]).returns(T::Array[String]) }
+          def self.validate_compatibility(schema)
+            issues = []
+
+            # Check for deeply nested objects (Gemini has depth limits)
+            depth = calculate_depth(schema)
+            if depth > 5
+              issues << "Schema depth (#{depth}) exceeds recommended limit of 5 levels"
+            end
+
+            issues
+          end
+
+          private
+
+          sig { params(dspy_schema: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+          def self.convert_dspy_schema_to_gemini(dspy_schema)
+            result = {
+              type: "object",
+              properties: {},
+              required: []
+            }
+
+            # Convert properties
+            properties = dspy_schema[:properties] || {}
+            properties.each do |prop_name, prop_schema|
+              result[:properties][prop_name] = convert_property_to_gemini(prop_schema)
+            end
+
+            # Set required fields
+            result[:required] = (dspy_schema[:required] || []).map(&:to_s)
+
+            result
+          end
+
+          sig { params(property_schema: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+          def self.convert_property_to_gemini(property_schema)
+            case property_schema[:type]
+            when "string"
+              result = { type: "string" }
+              result[:enum] = property_schema[:enum] if property_schema[:enum]
+              result
+            when "integer"
+              { type: "integer" }
+            when "number"
+              { type: "number" }
+            when "boolean"
+              { type: "boolean" }
+            when "array"
+              {
+                type: "array",
+                items: convert_property_to_gemini(property_schema[:items] || { type: "string" })
+              }
+            when "object"
+              result = { type: "object" }
+              
+              if property_schema[:properties]
+                result[:properties] = {}
+                property_schema[:properties].each do |nested_prop, nested_schema|
+                  result[:properties][nested_prop] = convert_property_to_gemini(nested_schema)
+                end
+                
+                # Set required fields for nested objects
+                if property_schema[:required]
+                  result[:required] = property_schema[:required].map(&:to_s)
+                end
+              end
+              
+              result
+            else
+              # Default to string for unknown types
+              { type: "string" }
+            end
+          end
+
+          sig { params(schema: T::Hash[Symbol, T.untyped], current_depth: Integer).returns(Integer) }
+          def self.calculate_depth(schema, current_depth = 0)
+            return current_depth unless schema.is_a?(Hash)
+
+            max_depth = current_depth
+
+            # Check properties
+            if schema[:properties].is_a?(Hash)
+              schema[:properties].each_value do |prop|
+                if prop.is_a?(Hash)
+                  prop_depth = calculate_depth(prop, current_depth + 1)
+                  max_depth = [max_depth, prop_depth].max
+                end
+              end
+            end
+
+            # Check array items
+            if schema[:items].is_a?(Hash)
+              items_depth = calculate_depth(schema[:items], current_depth + 1)
+              max_depth = [max_depth, items_depth].max
+            end
+
+            max_depth
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dspy/lm/adapters/gemini_adapter.rb

@@ -7,10 +7,12 @@ require_relative '../vision_models'
 module DSPy
   class LM
     class GeminiAdapter < Adapter
-      def initialize(model:, api_key:)
-        super
+      def initialize(model:, api_key:, structured_outputs: false)
+        super(model: model, api_key: api_key)
         validate_api_key!(api_key, 'gemini')
         
+        @structured_outputs_enabled = structured_outputs
+        
         @client = Gemini.new(
           credentials: {
             service: 'generative-language-api',

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative "base_strategy"
+require_relative "../adapters/gemini/schema_converter"
+
+module DSPy
+  class LM
+    module Strategies
+      # Strategy for using Gemini's native structured output feature
+      class GeminiStructuredOutputStrategy < BaseStrategy
+        extend T::Sig
+
+        sig { override.returns(T::Boolean) }
+        def available?
+          # Check if adapter is Gemini and supports structured outputs
+          return false unless adapter.is_a?(DSPy::LM::GeminiAdapter)
+          return false unless adapter.instance_variable_get(:@structured_outputs_enabled)
+          
+          DSPy::LM::Adapters::Gemini::SchemaConverter.supports_structured_outputs?(adapter.model)
+        end
+
+        sig { override.returns(Integer) }
+        def priority
+          100 # Highest priority - native structured outputs are most reliable
+        end
+
+        sig { override.returns(String) }
+        def name
+          "gemini_structured_output"
+        end
+
+        sig { override.params(messages: T::Array[T::Hash[Symbol, String]], request_params: T::Hash[Symbol, T.untyped]).void }
+        def prepare_request(messages, request_params)
+          # Convert signature to Gemini schema format
+          schema = DSPy::LM::Adapters::Gemini::SchemaConverter.to_gemini_format(signature_class)
+          
+          # Add generation_config for structured output
+          request_params[:generation_config] = {
+            response_mime_type: "application/json",
+            response_schema: schema
+          }
+        end
+
+        sig { override.params(response: DSPy::LM::Response).returns(T.nilable(String)) }
+        def extract_json(response)
+          # With Gemini structured outputs, the response should already be valid JSON
+          # Just return the content as-is
+          response.content
+        end
+
+        sig { override.params(error: StandardError).returns(T::Boolean) }
+        def handle_error(error)
+          # Handle Gemini-specific structured output errors
+          error_msg = error.message.to_s.downcase
+          if error_msg.include?("schema") || error_msg.include?("generation_config") || error_msg.include?("response_schema")
+            # Log the error and return true to indicate we handled it
+            # This allows fallback to another strategy
+            DSPy.logger.warn("Gemini structured output failed: #{error.message}")
+            true
+          else
+            false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dspy/lm/strategy_selector.rb

@@ -5,6 +5,7 @@ require_relative "strategies/base_strategy"
 require_relative "strategies/openai_structured_output_strategy"
 require_relative "strategies/anthropic_tool_use_strategy"
 require_relative "strategies/anthropic_extraction_strategy"
+require_relative "strategies/gemini_structured_output_strategy"
 require_relative "strategies/enhanced_prompting_strategy"
 
 module DSPy
@@ -13,11 +14,23 @@ module DSPy
     class StrategySelector
       extend T::Sig
 
+      # Strategy names enum for type safety
+      class StrategyName < T::Enum
+        enums do
+          OpenAIStructuredOutput = new('openai_structured_output')
+          AnthropicToolUse = new('anthropic_tool_use')  
+          AnthropicExtraction = new('anthropic_extraction')
+          GeminiStructuredOutput = new('gemini_structured_output')
+          EnhancedPrompting = new('enhanced_prompting')
+        end
+      end
+
       # Available strategies in order of registration
       STRATEGIES = [
         Strategies::OpenAIStructuredOutputStrategy,
         Strategies::AnthropicToolUseStrategy,
         Strategies::AnthropicExtractionStrategy,
+        Strategies::GeminiStructuredOutputStrategy,
         Strategies::EnhancedPromptingStrategy
       ].freeze
 
@@ -38,7 +51,7 @@ module DSPy
           
           # If strict strategy not available, fall back to compatible for Strict preference
           if is_strict_preference?(DSPy.config.structured_outputs.strategy)
-            compatible_strategy = find_strategy_by_name("enhanced_prompting")
+            compatible_strategy = find_strategy_by_name(StrategyName::EnhancedPrompting)
             return compatible_strategy if compatible_strategy&.available?
           end
           
@@ -65,7 +78,7 @@ module DSPy
       end
 
       # Check if a specific strategy is available
-      sig { params(strategy_name: String).returns(T::Boolean) }
+      sig { params(strategy_name: StrategyName).returns(T::Boolean) }
       def strategy_available?(strategy_name)
         strategy = find_strategy_by_name(strategy_name)
         strategy&.available? || false
@@ -82,7 +95,7 @@ module DSPy
           select_provider_optimized_strategy
         when DSPy::Strategy::Compatible
           # Use enhanced prompting
-          find_strategy_by_name("enhanced_prompting")
+          find_strategy_by_name(StrategyName::EnhancedPrompting)
         else
           nil
         end
@@ -98,15 +111,19 @@ module DSPy
       sig { returns(T.nilable(Strategies::BaseStrategy)) }
       def select_provider_optimized_strategy
         # Try OpenAI structured output first
-        openai_strategy = find_strategy_by_name("openai_structured_output")
+        openai_strategy = find_strategy_by_name(StrategyName::OpenAIStructuredOutput)
         return openai_strategy if openai_strategy&.available?
         
+        # Try Gemini structured output
+        gemini_strategy = find_strategy_by_name(StrategyName::GeminiStructuredOutput)
+        return gemini_strategy if gemini_strategy&.available?
+        
         # Try Anthropic tool use first
-        anthropic_tool_strategy = find_strategy_by_name("anthropic_tool_use")
+        anthropic_tool_strategy = find_strategy_by_name(StrategyName::AnthropicToolUse)
         return anthropic_tool_strategy if anthropic_tool_strategy&.available?
         
         # Fall back to Anthropic extraction
-        anthropic_strategy = find_strategy_by_name("anthropic_extraction")
+        anthropic_strategy = find_strategy_by_name(StrategyName::AnthropicExtraction)
         return anthropic_strategy if anthropic_strategy&.available?
         
         # No provider-specific strategy available
@@ -118,9 +135,9 @@ module DSPy
         STRATEGIES.map { |klass| klass.new(@adapter, @signature_class) }
       end
 
-      sig { params(name: String).returns(T.nilable(Strategies::BaseStrategy)) }
+      sig { params(name: StrategyName).returns(T.nilable(Strategies::BaseStrategy)) }
       def find_strategy_by_name(name)
-        @strategies.find { |s| s.name == name }
+        @strategies.find { |s| s.name == name.serialize }
       end
     end
   end

data/lib/dspy/teleprompt/mipro_v2.rb

@@ -32,6 +32,7 @@ module DSPy
     # instruction generation, and Bayesian optimization
     class MIPROv2 < Teleprompter
       extend T::Sig
+      include Dry::Configurable
 
       # Auto-configuration modes for different optimization needs
       module AutoMode
@@ -44,15 +45,17 @@ module DSPy
           ).returns(MIPROv2)
         end
         def self.light(metric: nil, **kwargs)
-          config = MIPROv2Config.new
-          config.num_trials = 6
-          config.num_instruction_candidates = 3
-          config.max_bootstrapped_examples = 2
-          config.max_labeled_examples = 8
-          config.bootstrap_sets = 3
-          config.optimization_strategy = "greedy"
-          config.early_stopping_patience = 2
-          MIPROv2.new(metric: metric, config: config, **kwargs)
+          optimizer = MIPROv2.new(metric: metric, **kwargs)
+          optimizer.configure do |config|
+            config.num_trials = 6
+            config.num_instruction_candidates = 3
+            config.max_bootstrapped_examples = 2
+            config.max_labeled_examples = 8
+            config.bootstrap_sets = 3
+            config.optimization_strategy = :greedy
+            config.early_stopping_patience = 2
+          end
+          optimizer
         end
 
         sig do
@@ -62,15 +65,17 @@ module DSPy
           ).returns(MIPROv2)
         end
         def self.medium(metric: nil, **kwargs)
-          config = MIPROv2Config.new
-          config.num_trials = 12
-          config.num_instruction_candidates = 5
-          config.max_bootstrapped_examples = 4
-          config.max_labeled_examples = 16
-          config.bootstrap_sets = 5
-          config.optimization_strategy = "adaptive"
-          config.early_stopping_patience = 3
-          MIPROv2.new(metric: metric, config: config, **kwargs)
+          optimizer = MIPROv2.new(metric: metric, **kwargs)
+          optimizer.configure do |config|
+            config.num_trials = 12
+            config.num_instruction_candidates = 5
+            config.max_bootstrapped_examples = 4
+            config.max_labeled_examples = 16
+            config.bootstrap_sets = 5
+            config.optimization_strategy = :adaptive
+            config.early_stopping_patience = 3
+          end
+          optimizer
         end
 
         sig do
@@ -80,135 +85,102 @@ module DSPy
           ).returns(MIPROv2)
         end
         def self.heavy(metric: nil, **kwargs)
-          config = MIPROv2Config.new
-          config.num_trials = 18
-          config.num_instruction_candidates = 8
-          config.max_bootstrapped_examples = 6
-          config.max_labeled_examples = 24
-          config.bootstrap_sets = 8
-          config.optimization_strategy = "bayesian"
-          config.early_stopping_patience = 5
-          MIPROv2.new(metric: metric, config: config, **kwargs)
-        end
-      end
-
-      # Configuration for MIPROv2 optimization
-      class MIPROv2Config < Config
-        extend T::Sig
-
-        sig { returns(Integer) }
-        attr_accessor :num_trials
-
-        sig { returns(Integer) }
-        attr_accessor :num_instruction_candidates
-
-        sig { returns(Integer) }
-        attr_accessor :bootstrap_sets
-
-        sig { returns(String) }
-        attr_accessor :optimization_strategy
-
-        sig { returns(Float) }
-        attr_accessor :init_temperature
-
-        sig { returns(Float) }
-        attr_accessor :final_temperature
-
-        sig { returns(Integer) }
-        attr_accessor :early_stopping_patience
-
-        sig { returns(T::Boolean) }
-        attr_accessor :use_bayesian_optimization
-
-        sig { returns(T::Boolean) }
-        attr_accessor :track_diversity
-
-        sig { returns(DSPy::Propose::GroundedProposer::Config) }
-        attr_accessor :proposer_config
-
-        sig { void }
-        def initialize
-          super
-          @num_trials = 12
-          @num_instruction_candidates = 5
-          @bootstrap_sets = 5
-          @optimization_strategy = "adaptive" # greedy, adaptive, bayesian
-          @init_temperature = 1.0
-          @final_temperature = 0.1
-          @early_stopping_patience = 3
-          @use_bayesian_optimization = true
-          @track_diversity = true
-          @proposer_config = DSPy::Propose::GroundedProposer::Config.new
+          optimizer = MIPROv2.new(metric: metric, **kwargs)
+          optimizer.configure do |config|
+            config.num_trials = 18
+            config.num_instruction_candidates = 8
+            config.max_bootstrapped_examples = 6
+            config.max_labeled_examples = 24
+            config.bootstrap_sets = 8
+            config.optimization_strategy = :bayesian
+            config.early_stopping_patience = 5
+          end
+          optimizer
+        end
+      end
+
+      # Dry-configurable settings for MIPROv2
+      setting :num_trials, default: 12
+      setting :num_instruction_candidates, default: 5
+      setting :bootstrap_sets, default: 5
+      setting :max_bootstrapped_examples, default: 4
+      setting :max_labeled_examples, default: 16
+      setting :optimization_strategy, default: OptimizationStrategy::Adaptive, constructor: ->(value) {
+        # Coerce symbols to enum values
+        case value
+        when :greedy then OptimizationStrategy::Greedy
+        when :adaptive then OptimizationStrategy::Adaptive
+        when :bayesian then OptimizationStrategy::Bayesian
+        when OptimizationStrategy then value
+        when nil then OptimizationStrategy::Adaptive
+        else
+          raise ArgumentError, "Invalid optimization strategy: #{value}. Must be one of :greedy, :adaptive, :bayesian"
         end
+      }
+      setting :init_temperature, default: 1.0
+      setting :final_temperature, default: 0.1
+      setting :early_stopping_patience, default: 3
+      setting :use_bayesian_optimization, default: true
+      setting :track_diversity, default: true
+      setting :max_errors, default: 3
+      setting :num_threads, default: 1
 
-        sig { returns(T::Hash[Symbol, T.untyped]) }
-        def to_h
-          super.merge({
-            num_trials: @num_trials,
-            num_instruction_candidates: @num_instruction_candidates,
-            bootstrap_sets: @bootstrap_sets,
-            optimization_strategy: @optimization_strategy,
-            init_temperature: @init_temperature,
-            final_temperature: @final_temperature,
-            early_stopping_patience: @early_stopping_patience,
-            use_bayesian_optimization: @use_bayesian_optimization,
-            track_diversity: @track_diversity
-          })
+      # Class-level configuration method - sets defaults for new instances
+      def self.configure(&block)
+        if block_given?
+          # Store configuration in a class variable for new instances
+          @default_config_block = block
         end
       end
 
-      # Candidate configuration for optimization trials
-      class CandidateConfig
-        extend T::Sig
-        include Dry::Configurable
-
-        # Configuration settings
-        setting :instruction, default: ""
-        setting :few_shot_examples, default: []
-        setting :type, default: CandidateType::Baseline
-        setting :metadata, default: {}
+      # Get the default configuration block
+      def self.default_config_block
+        @default_config_block
+      end
 
-        sig { returns(String) }
-        def config_id
-          @config_id ||= generate_config_id
-        end
 
-        sig { void }
-        def finalize!
-          # Freeze settings after configuration to prevent mutation
-          config.instruction = config.instruction.freeze
-          config.few_shot_examples = config.few_shot_examples.freeze  
-          config.metadata = config.metadata.freeze
+      # Simple data structure for evaluated candidate configurations (immutable)
+      EvaluatedCandidate = Data.define(
+        :instruction,
+        :few_shot_examples,
+        :type,
+        :metadata,
+        :config_id
+      ) do
+        extend T::Sig
+        
+        # Generate a config ID based on content
+        sig { params(instruction: String, few_shot_examples: T::Array[T.untyped], type: CandidateType, metadata: T::Hash[Symbol, T.untyped]).returns(EvaluatedCandidate) }
+        def self.create(instruction:, few_shot_examples: [], type: CandidateType::Baseline, metadata: {})
+          content = "#{instruction}_#{few_shot_examples.size}_#{type.serialize}_#{metadata.hash}"
+          config_id = Digest::SHA256.hexdigest(content)[0, 12]
           
-          # Generate ID after finalization
-          @config_id = generate_config_id
+          new(
+            instruction: instruction.freeze,
+            few_shot_examples: few_shot_examples.freeze,
+            type: type,
+            metadata: metadata.freeze,
+            config_id: config_id
+          )
         end
 
         sig { returns(T::Hash[Symbol, T.untyped]) }
         def to_h
           {
-            instruction: config.instruction,
-            few_shot_examples: config.few_shot_examples.size,
-            type: config.type.serialize,
-            metadata: config.metadata,
+            instruction: instruction,
+            few_shot_examples: few_shot_examples.size,
+            type: type.serialize,
+            metadata: metadata,
             config_id: config_id
           }
         end
-
-        private
-
-        sig { returns(String) }
-        def generate_config_id
-          content = "#{config.instruction}_#{config.few_shot_examples.size}_#{config.type.serialize}_#{config.metadata.hash}"
-          Digest::SHA256.hexdigest(content)[0, 12]
-        end
       end
 
       # Result of MIPROv2 optimization
       class MIPROv2Result < OptimizationResult
         extend T::Sig
 
-        sig { returns(T::Array[CandidateConfig]) }
+        sig { returns(T::Array[EvaluatedCandidate]) }
         attr_reader :evaluated_candidates
 
         sig { returns(T::Hash[Symbol, T.untyped]) }
@@ -228,7 +200,7 @@ module DSPy
             optimized_program: T.untyped,
             scores: T::Hash[Symbol, T.untyped],
             history: T::Hash[Symbol, T.untyped],
-            evaluated_candidates: T::Array[CandidateConfig],
+            evaluated_candidates: T::Array[EvaluatedCandidate],
             optimization_trace: T::Hash[Symbol, T.untyped],
             bootstrap_statistics: T::Hash[Symbol, T.untyped],
             proposal_statistics: T::Hash[Symbol, T.untyped],
@@ -272,18 +244,25 @@ module DSPy
       sig { returns(T.nilable(DSPy::Propose::GroundedProposer)) }
       attr_reader :proposer
 
-      sig do
-        params(
-          metric: T.nilable(T.proc.params(arg0: T.untyped, arg1: T.untyped).returns(T.untyped)),
-          config: T.nilable(MIPROv2Config)
-        ).void
-      end
-      def initialize(metric: nil, config: nil)
-        @mipro_config = config || MIPROv2Config.new
-        # Call parent teleprompter initializer, which handles dry-configurable internally
-        super(metric: metric, config: @mipro_config)
+      # Override dry-configurable's initialize to add our parameter validation
+      def initialize(metric: nil, **kwargs)
+        # Reject old config parameter pattern
+        if kwargs.key?(:config)
+          raise ArgumentError, "config parameter is no longer supported. Use .configure blocks instead."
+        end
+        
+        # Let dry-configurable handle its initialization
+        super(**kwargs)
+        
+        # Apply class-level configuration if it exists
+        if self.class.default_config_block
+          configure(&self.class.default_config_block)
+        end
         
-        @proposer = DSPy::Propose::GroundedProposer.new(config: @mipro_config.proposer_config)
+        @metric = metric
+        
+        # Initialize proposer with a basic config for now (will be updated later)  
+        @proposer = DSPy::Propose::GroundedProposer.new(config: DSPy::Propose::GroundedProposer::Config.new)
         @optimization_trace = []
         @evaluated_candidates = []
       end
@@ -302,8 +281,8 @@ module DSPy
         instrument_step('miprov2_compile', {
           trainset_size: trainset.size,
           valset_size: valset&.size || 0,
-          num_trials: @mipro_config.num_trials,
-          optimization_strategy: @mipro_config.optimization_strategy,
+          num_trials: config.num_trials,
+          optimization_strategy: config.optimization_strategy,
           mode: infer_auto_mode
         }) do
           # Convert examples to typed format
@@ -363,11 +342,11 @@ module DSPy
       sig { params(program: T.untyped, trainset: T::Array[DSPy::Example]).returns(Utils::BootstrapResult) }
       def phase_1_bootstrap(program, trainset)
         bootstrap_config = Utils::BootstrapConfig.new
-        bootstrap_config.max_bootstrapped_examples = @mipro_config.max_bootstrapped_examples
-        bootstrap_config.max_labeled_examples = @mipro_config.max_labeled_examples
-        bootstrap_config.num_candidate_sets = @mipro_config.bootstrap_sets
-        bootstrap_config.max_errors = @mipro_config.max_errors
-        bootstrap_config.num_threads = @mipro_config.num_threads
+        bootstrap_config.max_bootstrapped_examples = config.max_bootstrapped_examples
+        bootstrap_config.max_labeled_examples = config.max_labeled_examples
+        bootstrap_config.num_candidate_sets = config.bootstrap_sets
+        bootstrap_config.max_errors = config.max_errors
+        bootstrap_config.num_threads = config.num_threads
 
         Utils.create_n_fewshot_demo_sets(program, trainset, config: bootstrap_config, metric: @metric)
       end
@@ -392,7 +371,7 @@ module DSPy
         raise ArgumentError, "Cannot extract signature class from program" unless signature_class
 
         # Configure proposer for this optimization run
-        @mipro_config.proposer_config.num_instruction_candidates = @mipro_config.num_instruction_candidates
+        @proposer.config.num_instruction_candidates = config.num_instruction_candidates
 
         @proposer.propose_instructions(
           signature_class,
@@ -425,7 +404,7 @@ module DSPy
         best_program = nil
         best_evaluation_result = nil
         
-        @mipro_config.num_trials.times do |trial_idx|
+        config.num_trials.times do |trial_idx|
           trials_completed = trial_idx + 1
           
           # Select next candidate based on optimization strategy
@@ -434,8 +413,8 @@ module DSPy
           emit_event('trial_start', {
             trial_number: trials_completed,
             candidate_id: candidate.config_id,
-            instruction_preview: candidate.config.instruction[0, 50],
-            num_few_shot: candidate.config.few_shot_examples.size
+            instruction_preview: candidate.instruction[0, 50],
+            num_few_shot: candidate.few_shot_examples.size
           })
 
           begin
@@ -494,37 +473,40 @@ module DSPy
         params(
           proposal_result: DSPy::Propose::GroundedProposer::ProposalResult,
           bootstrap_result: Utils::BootstrapResult
-        ).returns(T::Array[CandidateConfig])
+        ).returns(T::Array[EvaluatedCandidate])
       end
       def generate_candidate_configurations(proposal_result, bootstrap_result)
         candidates = []
         
         # Base configuration (no modifications)
-        candidates << create_candidate_config do |config|
-          config.instruction = ""
-          config.few_shot_examples = []
-          config.type = CandidateType::Baseline
-          config.metadata = {}
-        end
+        candidates << EvaluatedCandidate.new(
+          instruction: "",
+          few_shot_examples: [],
+          type: CandidateType::Baseline,
+          metadata: {},
+          config_id: SecureRandom.hex(6)
+        )
         
         # Instruction-only candidates
         proposal_result.candidate_instructions.each_with_index do |instruction, idx|
-          candidates << create_candidate_config do |config|
-            config.instruction = instruction
-            config.few_shot_examples = []
-            config.type = CandidateType::InstructionOnly
-            config.metadata = { proposal_rank: idx }
-          end
+          candidates << EvaluatedCandidate.new(
+            instruction: instruction,
+            few_shot_examples: [],
+            type: CandidateType::InstructionOnly,
+            metadata: { proposal_rank: idx },
+            config_id: SecureRandom.hex(6)
+          )
         end
         
         # Few-shot only candidates
         bootstrap_result.candidate_sets.each_with_index do |candidate_set, idx|
-          candidates << create_candidate_config do |config|
-            config.instruction = ""
-            config.few_shot_examples = candidate_set
-            config.type = CandidateType::FewShotOnly
-            config.metadata = { bootstrap_rank: idx }
-          end
+          candidates << EvaluatedCandidate.new(
+            instruction: "",
+            few_shot_examples: candidate_set,
+            type: CandidateType::FewShotOnly,
+            metadata: { bootstrap_rank: idx },
+            config_id: SecureRandom.hex(6)
+          )
         end
         
         # Combined candidates (instruction + few-shot)
@@ -533,15 +515,16 @@ module DSPy
         
         top_instructions.each_with_index do |instruction, i_idx|
           top_bootstrap_sets.each_with_index do |candidate_set, b_idx|
-            candidates << create_candidate_config do |config|
-              config.instruction = instruction
-              config.few_shot_examples = candidate_set
-              config.type = CandidateType::Combined
-              config.metadata = { 
+            candidates << EvaluatedCandidate.new(
+              instruction: instruction,
+              few_shot_examples: candidate_set,
+              type: CandidateType::Combined,
+              metadata: { 
                 instruction_rank: i_idx, 
                 bootstrap_rank: b_idx 
-              }
-            end
+              },
+              config_id: SecureRandom.hex(6)
+            )
           end
         end
         
@@ -549,13 +532,13 @@ module DSPy
       end
 
       # Initialize optimization state for candidate selection
-      sig { params(candidates: T::Array[CandidateConfig]).returns(T::Hash[Symbol, T.untyped]) }
+      sig { params(candidates: T::Array[EvaluatedCandidate]).returns(T::Hash[Symbol, T.untyped]) }
       def initialize_optimization_state(candidates)
         {
           candidates: candidates,
           scores: {},
           exploration_counts: Hash.new(0),
-          temperature: @mipro_config.init_temperature,
+          temperature: config.init_temperature,
           best_score_history: [],
           diversity_scores: {},
           no_improvement_count: 0
@@ -565,18 +548,18 @@ module DSPy
       # Select next candidate based on optimization strategy
       sig do
         params(
-          candidates: T::Array[CandidateConfig],
+          candidates: T::Array[EvaluatedCandidate],
           state: T::Hash[Symbol, T.untyped],
           trial_idx: Integer
-        ).returns(CandidateConfig)
+        ).returns(EvaluatedCandidate)
       end
       def select_next_candidate(candidates, state, trial_idx)
-        case @mipro_config.optimization_strategy
-        when "greedy"
+        case config.optimization_strategy
+        when OptimizationStrategy::Greedy
           select_candidate_greedy(candidates, state)
-        when "adaptive"
+        when OptimizationStrategy::Adaptive
           select_candidate_adaptive(candidates, state, trial_idx)
-        when "bayesian"
+        when OptimizationStrategy::Bayesian
           select_candidate_bayesian(candidates, state, trial_idx)
         else
           candidates.sample # Random fallback
@@ -584,7 +567,7 @@ module DSPy
       end
 
       # Greedy candidate selection (exploit best known configurations)
-      sig { params(candidates: T::Array[CandidateConfig], state: T::Hash[Symbol, T.untyped]).returns(CandidateConfig) }
+      sig { params(candidates: T::Array[EvaluatedCandidate], state: T::Hash[Symbol, T.untyped]).returns(EvaluatedCandidate) }
       def select_candidate_greedy(candidates, state)
         # Prioritize unexplored candidates, then highest scoring
         unexplored = candidates.reject { |c| state[:scores].key?(c.config_id) }
@@ -598,15 +581,15 @@ module DSPy
       # Adaptive candidate selection (balance exploration and exploitation)
       sig do
         params(
-          candidates: T::Array[CandidateConfig],
+          candidates: T::Array[EvaluatedCandidate],
           state: T::Hash[Symbol, T.untyped],
           trial_idx: Integer
-        ).returns(CandidateConfig)
+        ).returns(EvaluatedCandidate)
       end
       def select_candidate_adaptive(candidates, state, trial_idx)
         # Update temperature based on progress
-        progress = trial_idx.to_f / @mipro_config.num_trials
-        state[:temperature] = @mipro_config.init_temperature * (1 - progress) + @mipro_config.final_temperature * progress
+        progress = trial_idx.to_f / config.num_trials
+        state[:temperature] = config.init_temperature * (1 - progress) + config.final_temperature * progress
         
         # Calculate selection scores combining exploitation and exploration
         candidate_scores = candidates.map do |candidate|
@@ -639,10 +622,10 @@ module DSPy
       # Bayesian candidate selection (use probabilistic model)
       sig do
         params(
-          candidates: T::Array[CandidateConfig],
+          candidates: T::Array[EvaluatedCandidate],
           state: T::Hash[Symbol, T.untyped],
           trial_idx: Integer
-        ).returns(CandidateConfig)
+        ).returns(EvaluatedCandidate)
       end
       def select_candidate_bayesian(candidates, state, trial_idx)
         # Need at least 3 observations to fit GP, otherwise fall back to adaptive
@@ -686,21 +669,9 @@ module DSPy
       
       private
 
-      # Helper method to create CandidateConfig with dry-configurable syntax
-      sig do
-        params(
-          block: T.proc.params(config: Dry::Configurable::Config).void
-        ).returns(CandidateConfig)
-      end
-      def create_candidate_config(&block)
-        candidate = CandidateConfig.new
-        candidate.configure(&block)
-        candidate.finalize!
-        candidate
-      end
       
       # Encode candidates as numerical features for Gaussian Process
-      sig { params(candidates: T::Array[CandidateConfig]).returns(T::Array[T::Array[Float]]) }
+      sig { params(candidates: T::Array[EvaluatedCandidate]).returns(T::Array[T::Array[Float]]) }
       def encode_candidates_for_gp(candidates)
         # Simple encoding: use hash of config as features
         # In practice, this could be more sophisticated (e.g., instruction embeddings)
@@ -715,7 +686,7 @@ module DSPy
           features << ((config_hash / 1_000_000) % 1000).to_f / 1000.0  # Feature 3: high bits
           
           # Add instruction length if available
-          instruction = candidate.config.instruction
+          instruction = candidate.instruction
           if instruction && !instruction.empty?
             features << [instruction.length.to_f / 100.0, 2.0].min  # Instruction length, capped at 200 chars
           else
@@ -730,7 +701,7 @@ module DSPy
       sig do
         params(
           program: T.untyped,
-          candidate: CandidateConfig,
+          candidate: EvaluatedCandidate,
           evaluation_set: T::Array[DSPy::Example]
         ).returns([Float, T.untyped, DSPy::Evaluate::BatchEvaluationResult])
       end
@@ -748,18 +719,18 @@ module DSPy
       end
 
       # Apply candidate configuration to program
-      sig { params(program: T.untyped, candidate: CandidateConfig).returns(T.untyped) }
+      sig { params(program: T.untyped, candidate: EvaluatedCandidate).returns(T.untyped) }
       def apply_candidate_configuration(program, candidate)
         modified_program = program
         
         # Apply instruction if provided
-        if !candidate.config.instruction.empty? && program.respond_to?(:with_instruction)
-          modified_program = modified_program.with_instruction(candidate.config.instruction)
+        if !candidate.instruction.empty? && program.respond_to?(:with_instruction)
+          modified_program = modified_program.with_instruction(candidate.instruction)
         end
         
         # Apply few-shot examples if provided
-        if candidate.config.few_shot_examples.any? && program.respond_to?(:with_examples)
-          few_shot_examples = candidate.config.few_shot_examples.map do |example|
+        if candidate.few_shot_examples.any? && program.respond_to?(:with_examples)
+          few_shot_examples = candidate.few_shot_examples.map do |example|
             DSPy::FewShotExample.new(
               input: example.input_values,
               output: example.expected_values,
@@ -776,7 +747,7 @@ module DSPy
       sig do
         params(
           state: T::Hash[Symbol, T.untyped],
-          candidate: CandidateConfig,
+          candidate: EvaluatedCandidate,
           score: Float
         ).void
       end
@@ -786,7 +757,7 @@ module DSPy
         state[:best_score_history] << score
         
         # Track diversity if enabled
-        if @mipro_config.track_diversity
+        if config.track_diversity
           state[:diversity_scores][candidate.config_id] = calculate_diversity_score(candidate)
         end
         
@@ -802,18 +773,18 @@ module DSPy
       sig { params(state: T::Hash[Symbol, T.untyped], trial_idx: Integer).returns(T::Boolean) }
       def should_early_stop?(state, trial_idx)
         # Don't stop too early
-        return false if trial_idx < @mipro_config.early_stopping_patience
+        return false if trial_idx < config.early_stopping_patience
         
         # Stop if no improvement for patience trials
-        state[:no_improvement_count] >= @mipro_config.early_stopping_patience
+        state[:no_improvement_count] >= config.early_stopping_patience
       end
 
       # Calculate diversity score for candidate
-      sig { params(candidate: CandidateConfig).returns(Float) }
+      sig { params(candidate: EvaluatedCandidate).returns(Float) }
       def calculate_diversity_score(candidate)
         # Simple diversity metric based on instruction length and few-shot count
-        instruction_diversity = candidate.config.instruction.length / 200.0
-        few_shot_diversity = candidate.config.few_shot_examples.size / 10.0
+        instruction_diversity = candidate.instruction.length / 200.0
+        few_shot_diversity = candidate.few_shot_examples.size / 10.0
         
         [instruction_diversity + few_shot_diversity, 1.0].min
       end
@@ -836,17 +807,17 @@ module DSPy
         
         history = {
           total_trials: optimization_result[:trials_completed],
-          optimization_strategy: @mipro_config.optimization_strategy,
-          early_stopped: optimization_result[:trials_completed] < @mipro_config.num_trials,
+          optimization_strategy: config.optimization_strategy,
+          early_stopped: optimization_result[:trials_completed] < config.num_trials,
           score_history: optimization_result[:optimization_state][:best_score_history]
         }
         
         metadata = {
           optimizer: "MIPROv2",
           auto_mode: infer_auto_mode,
-          best_instruction: best_candidate&.config&.instruction || "",
-          best_few_shot_count: best_candidate&.config&.few_shot_examples&.size || 0,
-          best_candidate_type: best_candidate&.config&.type&.serialize || "unknown",
+          best_instruction: best_candidate&.instruction || "",
+          best_few_shot_count: best_candidate&.few_shot_examples&.size || 0,
+          best_candidate_type: best_candidate&.type&.serialize || "unknown",
           optimization_timestamp: Time.now.iso8601
         }
         
@@ -917,7 +888,7 @@ module DSPy
       # Infer auto mode based on configuration
       sig { returns(String) }
       def infer_auto_mode
-        case @mipro_config.num_trials
+        case config.num_trials
         when 0..6 then "light"
         when 7..12 then "medium"
         else "heavy"

data/lib/dspy/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.26.0
+  version: 0.27.0
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
 bindir: bin
 cert_chain: []
-date: 2025-09-09 00:00:00.000000000 Z
+date: 2025-09-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -207,6 +207,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/schema_converter.rb
 - lib/dspy/lm/adapters/gemini_adapter.rb
 - lib/dspy/lm/adapters/ollama_adapter.rb
 - lib/dspy/lm/adapters/openai/schema_converter.rb
@@ -221,6 +222,7 @@ files:
 - 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