dspy 0.27.5 → 0.28.0

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

@@ -1,80 +0,0 @@
-# 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 JSON Schema format (supports oneOf/anyOf for unions)
-          schema = DSPy::LM::Adapters::Gemini::SchemaConverter.to_gemini_format(signature_class)
-          
-          # Add generation_config for structured output using JSON Schema format
-          request_params[:generation_config] = {
-            response_mime_type: "application/json",
-            response_json_schema: schema  # Use JSON Schema format for proper union support
-          }
-        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
-          
-          # Check for permanent errors that shouldn't be retried
-          permanent_error_patterns = [
-            "schema",
-            "generation_config", 
-            "response_schema",
-            "unknown name \"response_mime_type\"",
-            "unknown name \"response_schema\"",
-            "invalid json payload",
-            "no matching sse interaction found",  # VCR test configuration issue
-            "cannot find field"
-          ]
-          
-          if permanent_error_patterns.any? { |pattern| error_msg.include?(pattern) }
-            # These are permanent errors - no point retrying
-            DSPy.logger.debug("Gemini structured output failed (permanent error, skipping retries): #{error.message}")
-            true # Skip retries and try next strategy
-          else
-            # Unknown error - let retry logic handle it
-            false
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base_strategy"
-
-module DSPy
-  class LM
-    module Strategies
-      # Strategy for using OpenAI's native structured output feature
-      class OpenAIStructuredOutputStrategy < BaseStrategy
-        extend T::Sig
-
-        sig { override.returns(T::Boolean) }
-        def available?
-          # Check if adapter is OpenAI or Ollama and supports structured outputs
-          return false unless adapter.is_a?(DSPy::LM::OpenAIAdapter) || adapter.is_a?(DSPy::LM::OllamaAdapter)
-          return false unless adapter.instance_variable_get(:@structured_outputs_enabled)
-          
-          # For Ollama, we assume it supports basic structured outputs
-          if adapter.is_a?(DSPy::LM::OllamaAdapter)
-            return true
-          end
-          
-          DSPy::LM::Adapters::OpenAI::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
-          "openai_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)
-          # Add structured output format to request
-          response_format = DSPy::LM::Adapters::OpenAI::SchemaConverter.to_openai_format(signature_class)
-          request_params[:response_format] = response_format
-        end
-
-        sig { override.params(response: DSPy::LM::Response).returns(T.nilable(String)) }
-        def extract_json(response)
-          # With 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 OpenAI-specific structured output errors
-          if error.message.include?("response_format") || error.message.include?("Invalid schema")
-            # Log the error and return true to indicate we handled it
-            # This allows fallback to another strategy
-            DSPy.logger.warn("OpenAI structured output failed: #{error.message}")
-            true
-          else
-            false
-          end
-        end
-      end
-    end
-  end
-end

data/lib/dspy/lm/strategy_selector.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-require "sorbet-runtime"
-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
-  class LM
-    # Selects the best JSON extraction strategy based on the adapter and capabilities
-    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
-
-      sig { params(adapter: DSPy::LM::Adapter, signature_class: T.class_of(DSPy::Signature)).void }
-      def initialize(adapter, signature_class)
-        @adapter = adapter
-        @signature_class = signature_class
-        @strategies = build_strategies
-      end
-
-      # Select the best available strategy
-      sig { returns(Strategies::BaseStrategy) }
-      def select
-        # Allow manual override via configuration
-        if DSPy.config.structured_outputs.strategy
-          strategy = select_strategy_from_preference(DSPy.config.structured_outputs.strategy)
-          return strategy if strategy&.available?
-          
-          # 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(StrategyName::EnhancedPrompting)
-            return compatible_strategy if compatible_strategy&.available?
-          end
-          
-          DSPy.logger.warn("No available strategy found for preference '#{DSPy.config.structured_outputs.strategy}'")
-        end
-
-        # Select the highest priority available strategy
-        available_strategies = @strategies.select(&:available?)
-        
-        if available_strategies.empty?
-          raise "No JSON extraction strategies available for #{@adapter.class}"
-        end
-
-        selected = available_strategies.max_by(&:priority)
-        
-        DSPy.logger.debug("Selected JSON extraction strategy: #{selected.name}")
-        selected
-      end
-
-      # Get all available strategies
-      sig { returns(T::Array[Strategies::BaseStrategy]) }
-      def available_strategies
-        @strategies.select(&:available?)
-      end
-
-      # Check if a specific strategy is available
-      sig { params(strategy_name: StrategyName).returns(T::Boolean) }
-      def strategy_available?(strategy_name)
-        strategy = find_strategy_by_name(strategy_name)
-        strategy&.available? || false
-      end
-
-      private
-
-      # Select internal strategy based on user preference
-      sig { params(preference: DSPy::Strategy).returns(T.nilable(Strategies::BaseStrategy)) }
-      def select_strategy_from_preference(preference)
-        case preference
-        when DSPy::Strategy::Strict
-          # Try provider-optimized strategies first
-          select_provider_optimized_strategy
-        when DSPy::Strategy::Compatible
-          # Use enhanced prompting
-          find_strategy_by_name(StrategyName::EnhancedPrompting)
-        else
-          nil
-        end
-      end
-      
-      # Check if preference is for strict (provider-optimized) strategies
-      sig { params(preference: DSPy::Strategy).returns(T::Boolean) }
-      def is_strict_preference?(preference)
-        preference == DSPy::Strategy::Strict
-      end
-      
-      # Select the best provider-optimized strategy for the current adapter
-      sig { returns(T.nilable(Strategies::BaseStrategy)) }
-      def select_provider_optimized_strategy
-        # Try OpenAI structured output first
-        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(StrategyName::AnthropicToolUse)
-        return anthropic_tool_strategy if anthropic_tool_strategy&.available?
-        
-        # Fall back to Anthropic extraction
-        anthropic_strategy = find_strategy_by_name(StrategyName::AnthropicExtraction)
-        return anthropic_strategy if anthropic_strategy&.available?
-        
-        # No provider-specific strategy available
-        nil
-      end
-
-      sig { returns(T::Array[Strategies::BaseStrategy]) }
-      def build_strategies
-        STRATEGIES.map { |klass| klass.new(@adapter, @signature_class) }
-      end
-
-      sig { params(name: StrategyName).returns(T.nilable(Strategies::BaseStrategy)) }
-      def find_strategy_by_name(name)
-        @strategies.find { |s| s.name == name.serialize }
-      end
-    end
-  end
-end

data/lib/dspy/lm/structured_output_strategy.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "sorbet-runtime"
-
-module DSPy
-  class LM
-    # Enum for structured output strategies
-    class StructuredOutputStrategy < T::Enum
-      enums do
-        OpenAIStructuredOutput = new("openai_structured_output")
-        AnthropicToolUse = new("anthropic_tool_use")
-        AnthropicExtraction = new("anthropic_extraction")
-        EnhancedPrompting = new("enhanced_prompting")
-      end
-    end
-  end
-end

data/lib/dspy/strategy.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require "sorbet-runtime"
-
-module DSPy
-  # User-facing enum for structured output strategy preferences
-  class Strategy < T::Enum
-    enums do
-      # Use provider-optimized strategies when available (OpenAI structured outputs, Anthropic extraction)
-      # Falls back to Compatible if provider-specific strategy isn't available
-      Strict = new("strict")
-      
-      # Use enhanced prompting that works with any provider
-      # More compatible but potentially less reliable than provider-specific strategies
-      Compatible = new("compatible")
-    end
-  end
-end