dspy 0.30.1 → 0.31.0

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

@@ -1,291 +0,0 @@
-# frozen_string_literal: true
-
-require 'anthropic'
-require_relative '../vision_models'
-
-module DSPy
-  class LM
-    class AnthropicAdapter < Adapter
-      def initialize(model:, api_key:, structured_outputs: true)
-        super(model: model, api_key: api_key)
-        validate_api_key!(api_key, 'anthropic')
-        @client = Anthropic::Client.new(api_key: api_key)
-        @structured_outputs_enabled = structured_outputs
-      end
-
-      def chat(messages:, signature: nil, **extra_params, &block)
-        normalized_messages = normalize_messages(messages)
-        
-        # Validate vision support if images are present
-        if contains_images?(normalized_messages)
-          VisionModels.validate_vision_support!('anthropic', model)
-          # Convert messages to Anthropic format with proper image handling
-          normalized_messages = format_multimodal_messages(normalized_messages)
-        end
-        
-        # Anthropic requires system message to be separate from messages
-        system_message, user_messages = extract_system_message(normalized_messages)
-        
-        # Check if this is a tool use request
-        has_tools = extra_params.key?(:tools) && !extra_params[:tools].empty?
-        
-        # Apply JSON prefilling if needed for better Claude JSON compliance (but not for tool use)
-        unless has_tools || contains_images?(normalized_messages)
-          user_messages = prepare_messages_for_json(user_messages, system_message)
-        end
-        
-        request_params = {
-          model: model,
-          messages: user_messages,
-          max_tokens: 4096, # Required for Anthropic
-          temperature: 0.0 # DSPy default for deterministic responses
-        }.merge(extra_params)
-
-        # Add system message if present
-        request_params[:system] = system_message if system_message
-
-        # Add streaming if block provided
-        if block_given?
-          request_params[:stream] = true
-        end
-
-        begin
-          if block_given?
-            content = ""
-            @client.messages.stream(**request_params) do |chunk|
-              if chunk.respond_to?(:delta) && chunk.delta.respond_to?(:text)
-                chunk_text = chunk.delta.text
-                content += chunk_text
-                block.call(chunk)
-              end
-            end
-            
-            # Create typed metadata for streaming response
-            metadata = ResponseMetadataFactory.create('anthropic', {
-              model: model,
-              streaming: true
-            })
-            
-            Response.new(
-              content: content,
-              usage: nil, # Usage not available in streaming
-              metadata: metadata
-            )
-          else
-            response = @client.messages.create(**request_params)
-            
-            if response.respond_to?(:error) && response.error
-              raise AdapterError, "Anthropic API error: #{response.error}"
-            end
-
-            # Handle both text content and tool use
-            content = ""
-            tool_calls = []
-            
-            if response.content.is_a?(Array)
-              response.content.each do |content_block|
-                case content_block.type.to_s
-                when "text"
-                  content += content_block.text
-                when "tool_use"
-                  tool_calls << {
-                    id: content_block.id,
-                    name: content_block.name,
-                    input: content_block.input
-                  }
-                end
-              end
-            end
-            
-            usage = response.usage
-
-            # Convert usage data to typed struct
-            usage_struct = UsageFactory.create('anthropic', usage)
-            
-            metadata = {
-              provider: 'anthropic',
-              model: model,
-              response_id: response.id,
-              role: response.role
-            }
-            
-            # Add tool calls to metadata if present
-            metadata[:tool_calls] = tool_calls unless tool_calls.empty?
-            
-            # Create typed metadata
-            typed_metadata = ResponseMetadataFactory.create('anthropic', metadata)
-            
-            Response.new(
-              content: content,
-              usage: usage_struct,
-              metadata: typed_metadata
-            )
-          end
-        rescue => e
-          # Check for specific image-related errors in the message
-          error_msg = e.message.to_s
-          
-          if error_msg.include?('Could not process image')
-            raise AdapterError, "Image processing failed: #{error_msg}. Ensure your image is a valid PNG, JPEG, GIF, or WebP format, properly base64-encoded, and under 5MB."
-          elsif error_msg.include?('image')
-            raise AdapterError, "Image error: #{error_msg}. Anthropic requires base64-encoded images (URLs are not supported)."
-          elsif error_msg.include?('rate')
-            raise AdapterError, "Anthropic rate limit exceeded: #{error_msg}. Please wait and try again."
-          elsif error_msg.include?('authentication') || error_msg.include?('API key')
-            raise AdapterError, "Anthropic authentication failed: #{error_msg}. Check your API key."
-          else
-            # Generic error handling
-            raise AdapterError, "Anthropic adapter error: #{e.message}"
-          end
-        end
-      end
-
-      private
-
-      # Enhanced JSON extraction specifically for Claude models
-      # Handles multiple patterns of markdown-wrapped JSON responses
-      def extract_json_from_response(content)
-        return content if content.nil? || content.empty?
-        
-        # Pattern 1: ```json blocks
-        if content.include?('```json')
-          extracted = content[/```json\s*\n(.*?)\n```/m, 1]
-          return extracted.strip if extracted
-        end
-        
-        # Pattern 2: ## Output values header
-        if content.include?('## Output values')
-          extracted = content.split('## Output values').last
-                            .gsub(/```json\s*\n/, '')
-                            .gsub(/\n```.*/, '')
-                            .strip
-          return extracted if extracted && !extracted.empty?
-        end
-        
-        # Pattern 3: Generic code blocks (check if it looks like JSON)
-        if content.include?('```')
-          extracted = content[/```\s*\n(.*?)\n```/m, 1]
-          return extracted.strip if extracted && looks_like_json?(extracted)
-        end
-        
-        # Pattern 4: Already valid JSON or fallback
-        content.strip
-      end
-
-      # Simple heuristic to check if content looks like JSON
-      def looks_like_json?(str)
-        return false if str.nil? || str.empty?
-        trimmed = str.strip
-        (trimmed.start_with?('{') && trimmed.end_with?('}')) ||
-        (trimmed.start_with?('[') && trimmed.end_with?(']'))
-      end
-
-      # Prepare messages for JSON output by adding prefilling and strong instructions
-      def prepare_messages_for_json(user_messages, system_message)
-        return user_messages unless requires_json_output?(user_messages, system_message)
-        return user_messages unless tends_to_wrap_json?
-        
-        # Add strong JSON instruction to the last user message if not already present
-        enhanced_messages = enhance_json_instructions(user_messages)
-        
-        # Only add prefill for models that support it and temporarily disable for testing
-        if false # supports_prefilling? - temporarily disabled
-          add_json_prefill(enhanced_messages)
-        else
-          enhanced_messages
-        end
-      end
-
-      # Detect if the conversation requires JSON output
-      def requires_json_output?(user_messages, system_message)
-        # Check for JSON-related keywords in messages
-        all_content = [system_message] + user_messages.map { |m| m[:content] }
-        all_content.compact.any? do |content|
-          content.downcase.include?('json') || 
-          content.include?('```') ||
-          content.include?('{') ||
-          content.include?('output')
-        end
-      end
-
-      # Check if this is a Claude model that benefits from prefilling
-      def supports_prefilling?
-        # Claude models that work well with JSON prefilling
-        model.downcase.include?('claude')
-      end
-
-      # Check if this is a Claude model that tends to wrap JSON in markdown
-      def tends_to_wrap_json?
-        # All Claude models have this tendency, especially Opus variants
-        model.downcase.include?('claude')
-      end
-
-      # Enhance the last user message with strong JSON instructions
-      def enhance_json_instructions(user_messages)
-        return user_messages if user_messages.empty?
-        
-        enhanced_messages = user_messages.dup
-        last_message = enhanced_messages.last
-        
-        # Only add instruction if not already present
-        unless last_message[:content].include?('ONLY valid JSON')
-          # Use smart default instruction for Claude models
-          json_instruction = "\n\nIMPORTANT: Respond with ONLY valid JSON. No markdown formatting, no code blocks, no explanations. Start your response with '{' and end with '}'."
-          
-          last_message = last_message.dup
-          last_message[:content] = last_message[:content] + json_instruction
-          enhanced_messages[-1] = last_message
-        end
-        
-        enhanced_messages
-      end
-
-      # Add assistant message prefill to guide Claude
-      def add_json_prefill(user_messages)
-        user_messages + [{ role: "assistant", content: "{" }]
-      end
-
-      def extract_system_message(messages)
-        system_message = nil
-        user_messages = []
-
-        messages.each do |msg|
-          if msg[:role] == 'system'
-            system_message = msg[:content]
-          else
-            user_messages << msg
-          end
-        end
-
-        [system_message, user_messages]
-      end
-      
-      def format_multimodal_messages(messages)
-        messages.map do |msg|
-          if msg[:content].is_a?(Array)
-            # Convert multimodal content to Anthropic format
-            formatted_content = msg[:content].map do |item|
-              case item[:type]
-              when 'text'
-                { type: 'text', text: item[:text] }
-              when 'image'
-                # Validate image compatibility before formatting
-                item[:image].validate_for_provider!('anthropic')
-                item[:image].to_anthropic_format
-              else
-                item
-              end
-            end
-            
-            {
-              role: msg[:role],
-              content: formatted_content
-            }
-          else
-            msg
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-require "sorbet-runtime"
-
-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 (JSON + Schema)
-          # Based on official Google documentation: https://ai.google.dev/gemini-api/docs/models/gemini
-          # Last updated: Oct 2025
-          # Note: Gemini 1.5 series deprecated Oct 2025
-          STRUCTURED_OUTPUT_MODELS = T.let([
-            # Gemini 2.0 series
-            "gemini-2.0-flash",
-            "gemini-2.0-flash-lite",
-            # Gemini 2.5 series (current)
-            "gemini-2.5-pro",
-            "gemini-2.5-flash",
-            "gemini-2.5-flash-lite",
-            "gemini-2.5-flash-image"
-          ].freeze, T::Array[String])
-
-          # Models that do not support structured outputs or are deprecated
-          UNSUPPORTED_MODELS = T.let([
-            # Legacy Gemini 1.0 series
-            "gemini-pro",
-            "gemini-1.0-pro-002",
-            "gemini-1.0-pro",
-            # Deprecated Gemini 1.5 series (removed Oct 2025)
-            "gemini-1.5-pro",
-            "gemini-1.5-pro-preview-0514",
-            "gemini-1.5-pro-preview-0409",
-            "gemini-1.5-flash",
-            "gemini-1.5-flash-8b"
-          ].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)
-            # 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)
-            convert_dspy_schema_to_gemini(output_schema)
-          end
-
-          sig { params(model: String).returns(T::Boolean) }
-          def self.supports_structured_outputs?(model)
-            # Extract base model name without provider prefix
-            base_model = model.sub(/^gemini\//, "")
-            
-            # Check if it's a supported model or a newer version
-            STRUCTURED_OUTPUT_MODELS.any? { |supported| base_model.start_with?(supported) }
-          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)
-            # For Gemini's responseJsonSchema, we need pure JSON Schema format
-            # Remove OpenAPI-specific fields like "$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)
-            # Handle oneOf/anyOf schemas (union types) - Gemini supports these in responseJsonSchema
-            if property_schema[:oneOf]
-              return {
-                oneOf: property_schema[:oneOf].map { |schema| convert_property_to_gemini(schema) },
-                description: property_schema[:description]
-              }.compact
-            end
-            
-            if property_schema[:anyOf]
-              return {
-                anyOf: property_schema[:anyOf].map { |schema| convert_property_to_gemini(schema) },
-                description: property_schema[:description]
-              }.compact
-            end
-            
-            case property_schema[:type]
-            when "string"
-              result = { type: "string" }
-              # Gemini responseJsonSchema doesn't support const, so convert to single-value enum
-              # See: https://ai.google.dev/api/generate-content#FIELDS.response_json_schema
-              if property_schema[:const]
-                result[:enum] = [property_schema[:const]]
-              elsif property_schema[:enum]
-                result[:enum] = property_schema[:enum]
-              end
-              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

@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-require 'gemini-ai'
-require 'json'
-require_relative '../vision_models'
-
-module DSPy
-  class LM
-    class GeminiAdapter < Adapter
-      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
-        
-        # Disable streaming for VCR tests since SSE responses don't record properly
-        # But keep streaming enabled for SSEVCR tests (SSE-specific cassettes)
-        @use_streaming = true
-        begin
-          vcr_active = defined?(VCR) && VCR.current_cassette
-          ssevcr_active = defined?(SSEVCR) && SSEVCR.turned_on?
-          
-          # Only disable streaming if regular VCR is active but SSEVCR is not
-          @use_streaming = false if vcr_active && !ssevcr_active
-        rescue
-          # If VCR/SSEVCR is not available or any error occurs, use streaming
-          @use_streaming = true
-        end
-
-        @client = Gemini.new(
-          credentials: {
-            service: 'generative-language-api',
-            api_key: api_key,
-            version: 'v1beta'  # Use beta API version for structured outputs support
-          },
-          options: { 
-            model: model,
-            server_sent_events: @use_streaming
-          }
-        )
-      end
-
-      def chat(messages:, signature: nil, **extra_params, &block)
-        normalized_messages = normalize_messages(messages)
-        
-        # Validate vision support if images are present
-        if contains_images?(normalized_messages)
-          VisionModels.validate_vision_support!('gemini', model)
-          # Convert messages to Gemini format with proper image handling
-          normalized_messages = format_multimodal_messages(normalized_messages)
-        end
-        
-        # Convert DSPy message format to Gemini format
-        gemini_messages = convert_messages_to_gemini_format(normalized_messages)
-        
-        request_params = {
-          contents: gemini_messages
-        }.merge(extra_params)
-
-        begin
-          content = ""
-          final_response_data = nil
-          
-          # Check if we're using streaming or not
-          if @use_streaming
-            # Streaming mode
-            @client.stream_generate_content(request_params) do |chunk|
-              # Handle case where chunk might be a string (from SSE VCR)
-              if chunk.is_a?(String)
-                begin
-                  chunk = JSON.parse(chunk)
-                rescue JSON::ParserError => e
-                  raise AdapterError, "Failed to parse Gemini streaming response: #{e.message}"
-                end
-              end
-              
-              # Extract content from chunks
-              if chunk.dig('candidates', 0, 'content', 'parts')
-                chunk_text = extract_text_from_parts(chunk.dig('candidates', 0, 'content', 'parts'))
-                content += chunk_text
-                
-                # Call block only if provided (for real streaming)
-                block.call(chunk) if block_given?
-              end
-              
-              # Store final response data (usage, metadata) from last chunk
-              if chunk['usageMetadata'] || chunk.dig('candidates', 0, 'finishReason')
-                final_response_data = chunk
-              end
-            end
-          else
-            # Non-streaming mode (for VCR tests)
-            response = @client.generate_content(request_params)
-            
-            # Extract content from single response
-            if response.dig('candidates', 0, 'content', 'parts')
-              content = extract_text_from_parts(response.dig('candidates', 0, 'content', 'parts'))
-            end
-            
-            # Use response as final data
-            final_response_data = response
-          end
-          
-          # Extract usage information from final chunk
-          usage_data = final_response_data&.dig('usageMetadata')
-          usage_struct = usage_data ? UsageFactory.create('gemini', usage_data) : nil
-          
-          # Create metadata from final chunk
-          metadata = {
-            provider: 'gemini',
-            model: model,
-            finish_reason: final_response_data&.dig('candidates', 0, 'finishReason'),
-            safety_ratings: final_response_data&.dig('candidates', 0, 'safetyRatings'),
-            streaming: block_given?
-          }
-          
-          # Create typed metadata
-          typed_metadata = ResponseMetadataFactory.create('gemini', metadata)
-          
-          Response.new(
-            content: content,
-            usage: usage_struct,
-            metadata: typed_metadata
-          )
-        rescue => e
-          handle_gemini_error(e)
-        end
-      end
-
-      private
-
-      # Convert DSPy message format to Gemini format
-      def convert_messages_to_gemini_format(messages)
-        # Gemini expects contents array with role and parts
-        messages.map do |msg|
-          role = case msg[:role]
-                 when 'system'
-                   'user' # Gemini doesn't have explicit system role, merge with user
-                 when 'assistant'
-                   'model'
-                 else
-                   msg[:role]
-                 end
-          
-          if msg[:content].is_a?(Array)
-            # Multimodal content
-            parts = msg[:content].map do |item|
-              case item[:type]
-              when 'text'
-                { text: item[:text] }
-              when 'image'
-                item[:image].to_gemini_format
-              else
-                item
-              end
-            end
-            
-            { role: role, parts: parts }
-          else
-            # Text-only content
-            { role: role, parts: [{ text: msg[:content] }] }
-          end
-        end
-      end
-      
-      # Extract text content from Gemini parts array
-      def extract_text_from_parts(parts)
-        return "" unless parts.is_a?(Array)
-        
-        parts.map { |part| part['text'] }.compact.join
-      end
-      
-      # Format multimodal messages for Gemini
-      def format_multimodal_messages(messages)
-        messages.map do |msg|
-          if msg[:content].is_a?(Array)
-            # Convert multimodal content to Gemini format
-            formatted_content = msg[:content].map do |item|
-              case item[:type]
-              when 'text'
-                { type: 'text', text: item[:text] }
-              when 'image'
-                # Validate image compatibility before formatting
-                item[:image].validate_for_provider!('gemini')
-                item[:image].to_gemini_format
-              else
-                item
-              end
-            end
-            
-            {
-              role: msg[:role],
-              content: formatted_content
-            }
-          else
-            msg
-          end
-        end
-      end
-      
-      # Handle Gemini-specific errors
-      def handle_gemini_error(error)
-        error_msg = error.message.to_s
-        
-        if error_msg.include?('API_KEY') || error_msg.include?('status 400') || error_msg.include?('status 401') || error_msg.include?('status 403')
-          raise AdapterError, "Gemini authentication failed: #{error_msg}. Check your API key."
-        elsif error_msg.include?('RATE_LIMIT') || error_msg.downcase.include?('quota') || error_msg.include?('status 429')
-          raise AdapterError, "Gemini rate limit exceeded: #{error_msg}. Please wait and try again."
-        elsif error_msg.include?('SAFETY') || error_msg.include?('blocked')
-          raise AdapterError, "Gemini content was blocked by safety filters: #{error_msg}"
-        elsif error_msg.include?('image') || error_msg.include?('media')
-          raise AdapterError, "Gemini image processing failed: #{error_msg}. Ensure your image is a valid format and under size limits."
-        else
-          # Generic error handling
-          raise AdapterError, "Gemini adapter error: #{error_msg}"
-        end
-      end
-    end
-  end
-end