dspy 0.27.0 → 0.27.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bb3b493e5411fd1f18028a3177c99149c2507f4d05a100746b2da734daa6a63
-  data.tar.gz: 78d2325d7b28a1b393284ec765c0f9fa3048c60afd864e3fcec0a88aac96cdc7
+  metadata.gz: 07ebaf2db9b6279275ac4dd61ac4f994ed5415561b0063310f006db084306092
+  data.tar.gz: 8e8c1cbfcb36d9ffa4bfd68f62317fba7d5d32a6b1409ce43749f555a719fc97
 SHA512:
-  metadata.gz: c11ef22db12b776b0dacb648cc60312aedb398b13020991827b85eca169b319960e8c4f31cc8216c93a766f67ed779998ee22f932bc02cb4ba802ce58c0a4ff4
-  data.tar.gz: 68847a5ef35187be690b82e0bd1b30d4da7988c2bf1da9fd3820e4ae2315c96900f798b4580b1dcd236fa4c4e45a4289c57301b36b1c24564fda020ee174107b
+  metadata.gz: 8f19c7e01b5e03743457c9784b8cca05ef42e8002ff210dd59f08915f11ceb7c1c000f8b0eac6cd102c847f069194923a46c5197473ea53cda7616921ea1da26
+  data.tar.gz: 9ed8e5ec4e08eb83f17dbea912a7a14b28212968f36dc7adf6cad7dd7e62de8506e371e99bb4f8f1d785847b45783fdfada53dae3d1d039a4f8695aba54984b4

data/lib/dspy/chain_of_thought.rb

@@ -83,46 +83,38 @@ module DSPy
     sig { returns(T.class_of(DSPy::Signature)) }
     attr_reader :original_signature
 
-    # Override forward_untyped to add ChainOfThought-specific analysis and tracing
+    # Override forward_untyped to add ChainOfThought-specific analysis
+    # Let Module#forward handle the ChainOfThought span creation automatically
     sig { override.params(input_values: T.untyped).returns(T.untyped) }
     def forward_untyped(**input_values)
-      # Wrap in chain-specific span tracking (overrides parent's span attributes)
-      DSPy::Context.with_span(
-        operation: "#{self.class.name}.forward",
-        'langfuse.observation.type' => 'span',  # Use 'span' for proper timing
-        'langfuse.observation.input' => input_values.to_json,
-        'dspy.module' => 'ChainOfThought',
-        'dspy.module_type' => 'chain_of_thought',  # Semantic identifier
-        'dspy.signature' => @original_signature.name
-      ) do |span|
-        # Call parent prediction logic (which will create its own nested span)
-        prediction_result = super(**input_values)
-        
-        # Enhance span with reasoning data
-        if span && prediction_result
-          # Include reasoning in output for chain observation
-          output_with_reasoning = if prediction_result.respond_to?(:reasoning) && prediction_result.reasoning
-            output_hash = prediction_result.respond_to?(:to_h) ? prediction_result.to_h : {}
-            output_hash.merge(reasoning: prediction_result.reasoning)
-          else
-            prediction_result.respond_to?(:to_h) ? prediction_result.to_h : prediction_result.to_s
-          end
-          
-          span.set_attribute('langfuse.observation.output', DSPy::Utils::Serialization.to_json(output_with_reasoning))
-          
-          # Add reasoning metrics
-          if prediction_result.respond_to?(:reasoning) && prediction_result.reasoning
-            span.set_attribute('cot.reasoning_length', prediction_result.reasoning.length)
-            span.set_attribute('cot.has_reasoning', true)
-            span.set_attribute('cot.reasoning_steps', count_reasoning_steps(prediction_result.reasoning))
-          end
+      # Create a Predict instance and call its forward method (which will create Predict span via Module#forward)
+      # We can't call super.forward because that would go to Module#forward_untyped, not Module#forward
+      
+      # Create a temporary Predict instance with our enhanced signature to get the prediction
+      predict_instance = DSPy::Predict.new(@signature_class)
+      predict_instance.config.lm = self.lm  # Use the same LM configuration
+      
+      # Call predict's forward method, which will create the Predict span
+      prediction_result = predict_instance.forward(**input_values)
+      
+      # Add ChainOfThought-specific analysis and events
+      if DSPy::Observability.enabled? && prediction_result
+        # Add reasoning metrics via events
+        if prediction_result.respond_to?(:reasoning) && prediction_result.reasoning
+          DSPy.event('chain_of_thought.reasoning_metrics', {
+            'cot.reasoning_length' => prediction_result.reasoning.length,
+            'cot.has_reasoning' => true,
+            'cot.reasoning_steps' => count_reasoning_steps(prediction_result.reasoning),
+            'dspy.module_type' => 'chain_of_thought',
+            'dspy.signature' => @original_signature.name
+          })
         end
-        
-        # Analyze reasoning (emits events for backwards compatibility)
-        analyze_reasoning(prediction_result)
-        
-        prediction_result
       end
+      
+      # Analyze reasoning (emits events for backwards compatibility)
+      analyze_reasoning(prediction_result)
+      
+      prediction_result
     end
 
     private
@@ -204,7 +196,7 @@ module DSPy
     # Emits reasoning analysis instrumentation event
     sig { params(reasoning_content: String).void }
     def emit_reasoning_analysis(reasoning_content)
-      DSPy.log('chain_of_thought.reasoning_complete', **{
+      DSPy.event('chain_of_thought.reasoning_complete', {
         'dspy.signature' => @original_signature.name,
         'cot.reasoning_steps' => count_reasoning_steps(reasoning_content),
         'cot.reasoning_length' => reasoning_content.length,

data/lib/dspy/code_act.rb

@@ -355,7 +355,7 @@ module DSPy
 
     sig { params(iteration: Integer, thought: String, ruby_code: String, execution_result: T.nilable(String), error_message: T.nilable(String)).void }
     def emit_iteration_complete_event(iteration, thought, ruby_code, execution_result, error_message)
-      DSPy.log('codeact.iteration_complete', **{
+      DSPy.event('codeact.iteration_complete', {
         'codeact.iteration' => iteration,
         'codeact.thought' => thought,
         'codeact.ruby_code' => ruby_code,
@@ -368,7 +368,7 @@ module DSPy
     sig { params(iterations_count: Integer, final_answer: T.nilable(String), history: T::Array[CodeActHistoryEntry]).void }
     def handle_max_iterations_if_needed(iterations_count, final_answer, history)
       if iterations_count >= @max_iterations && final_answer.nil?
-        DSPy.log('codeact.max_iterations', **{
+        DSPy.event('codeact.max_iterations', {
           'codeact.iteration_count' => iterations_count,
           'codeact.max_iterations' => @max_iterations,
           'codeact.final_history_length' => history.length

data/lib/dspy/context.rb

@@ -6,29 +6,41 @@ module DSPy
   class Context
     class << self
       def current
-        # Check if we're in an async context (fiber created by async gem)
-        if in_async_context?
-          # Use Fiber storage for async contexts to enable inheritance
-          # Inherit from Thread.current if Fiber storage is not set
-          Fiber[:dspy_context] ||= Thread.current[:dspy_context] || {
-            trace_id: SecureRandom.uuid,
-            span_stack: []
-          }
-          
-          # Return Fiber storage in async contexts
-          Fiber[:dspy_context]
-        else
-          # Use Thread.current for regular synchronous contexts
-          Thread.current[:dspy_context] ||= {
-            trace_id: SecureRandom.uuid,
-            span_stack: []
-          }
-          
-          # Also sync to Fiber storage so async contexts can inherit it
-          Fiber[:dspy_context] = Thread.current[:dspy_context]
-          
-          Thread.current[:dspy_context]
+        # Use Thread storage as primary source to ensure thread isolation
+        # Fiber storage is used for OpenTelemetry context propagation within the same thread
+        
+        # Create a unique key for this thread to ensure isolation
+        thread_key = :"dspy_context_#{Thread.current.object_id}"
+        
+        # Always check thread-local storage first for proper isolation
+        if Thread.current[thread_key]
+          # Thread has context, ensure fiber inherits it for OpenTelemetry propagation
+          Fiber[:dspy_context] = Thread.current[thread_key]
+          Thread.current[:dspy_context] = Thread.current[thread_key]  # Keep for backward compatibility
+          return Thread.current[thread_key]
+        end
+        
+        # Check if current fiber has context that was set by this same thread
+        # This handles cases where context was set via OpenTelemetry propagation within the thread
+        if Fiber[:dspy_context] && Thread.current[:dspy_context] == Fiber[:dspy_context]
+          # This fiber context was set by this thread, safe to use
+          Thread.current[thread_key] = Fiber[:dspy_context]
+          return Fiber[:dspy_context]
         end
+        
+        # No existing context or context belongs to different thread - create new one
+        context = {
+          trace_id: SecureRandom.uuid,
+          span_stack: [],
+          otel_span_stack: []
+        }
+        
+        # Set in both Thread and Fiber storage
+        Thread.current[thread_key] = context
+        Thread.current[:dspy_context] = context  # Keep for backward compatibility
+        Fiber[:dspy_context] = context
+        
+        context
       end
       
       def with_span(operation:, **attributes)
@@ -65,22 +77,66 @@ module DSPy
             # Record start time for explicit duration tracking
             otel_start_time = Time.now
             
-            DSPy::Observability.tracer.in_span(
-              operation,
-              attributes: span_attributes,
-              kind: :internal
-            ) do |span|
-              result = yield(span)
-              
-              # Add explicit timing information to help Langfuse
-              if span
-                duration_ms = ((Time.now - otel_start_time) * 1000).round(3)
-                span.set_attribute('duration.ms', duration_ms)
-                span.set_attribute('langfuse.observation.startTime', otel_start_time.iso8601(3))
-                span.set_attribute('langfuse.observation.endTime', Time.now.iso8601(3))
+            # Get parent OpenTelemetry span for proper context propagation
+            parent_otel_span = current[:otel_span_stack].last
+            
+            # Create span with proper parent context
+            if parent_otel_span
+              # Use the parent span's context to ensure proper nesting
+              OpenTelemetry::Trace.with_span(parent_otel_span) do
+                DSPy::Observability.tracer.in_span(
+                  operation,
+                  attributes: span_attributes,
+                  kind: :internal
+                ) do |span|
+                  # Add to our OpenTelemetry span stack
+                  current[:otel_span_stack].push(span)
+                  
+                  begin
+                    result = yield(span)
+                    
+                    # Add explicit timing information to help Langfuse
+                    if span
+                      duration_ms = ((Time.now - otel_start_time) * 1000).round(3)
+                      span.set_attribute('duration.ms', duration_ms)
+                      span.set_attribute('langfuse.observation.startTime', otel_start_time.iso8601(3))
+                      span.set_attribute('langfuse.observation.endTime', Time.now.iso8601(3))
+                    end
+                    
+                    result
+                  ensure
+                    # Remove from our OpenTelemetry span stack
+                    current[:otel_span_stack].pop
+                  end
+                end
+              end
+            else
+              # Root span - no parent context needed
+              DSPy::Observability.tracer.in_span(
+                operation,
+                attributes: span_attributes,
+                kind: :internal
+              ) do |span|
+                # Add to our OpenTelemetry span stack
+                current[:otel_span_stack].push(span)
+                
+                begin
+                  result = yield(span)
+                  
+                  # Add explicit timing information to help Langfuse
+                  if span
+                    duration_ms = ((Time.now - otel_start_time) * 1000).round(3)
+                    span.set_attribute('duration.ms', duration_ms)
+                    span.set_attribute('langfuse.observation.startTime', otel_start_time.iso8601(3))
+                    span.set_attribute('langfuse.observation.endTime', Time.now.iso8601(3))
+                  end
+                  
+                  result
+                ensure
+                  # Remove from our OpenTelemetry span stack
+                  current[:otel_span_stack].pop
+                end
               end
-              
-              result
             end
           else
             yield(nil)
@@ -102,6 +158,9 @@ module DSPy
       end
       
       def clear!
+        # Clear both the thread-specific key and the legacy key
+        thread_key = :"dspy_context_#{Thread.current.object_id}"
+        Thread.current[thread_key] = nil
         Thread.current[:dspy_context] = nil
         Fiber[:dspy_context] = nil
       end

data/lib/dspy/errors.rb

@@ -7,6 +7,8 @@ module DSPy
   
   class DeserializationError < Error; end
   
+  class UnsupportedSchemaError < Error; end
+  
   class ConfigurationError < Error
     def self.missing_lm(module_name)
       new(<<~MESSAGE)

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "sorbet-runtime"
-require_relative "../../cache_manager"
 
 module DSPy
   class LM
@@ -11,57 +10,43 @@ module DSPy
         class SchemaConverter
           extend T::Sig
 
-          # Models that support structured outputs
+          # Models that support structured outputs (JSON + Schema)
+          # Based on official Google documentation and gemini-ai gem table
           STRUCTURED_OUTPUT_MODELS = T.let([
-            "gemini-1.5-pro",
-            "gemini-1.5-flash",
-            "gemini-2.0-flash-exp"
+            "gemini-1.5-pro",              # ✅ Full schema support (legacy)
+            "gemini-1.5-pro-preview-0514", # ✅ Full schema support (legacy)
+            "gemini-1.5-pro-preview-0409", # ✅ Full schema support (legacy)
+            "gemini-2.5-flash",            # ✅ Full schema support (2025 current)
+            "gemini-2.5-flash-lite"        # ✅ Full schema support (2025 current)
+          ].freeze, T::Array[String])
+
+          # Models that support JSON mode but NOT schema
+          JSON_ONLY_MODELS = T.let([
+            "gemini-pro",                   # 🟡 JSON only, no schema
+            "gemini-1.5-flash",             # 🟡 JSON only, no schema (legacy)
+            "gemini-1.5-flash-preview-0514", # 🟡 JSON only, no schema (legacy)
+            "gemini-1.0-pro-002",           # 🟡 JSON only, no schema
+            "gemini-1.0-pro",               # 🟡 JSON only, no schema
+            "gemini-2.0-flash-001",         # 🟡 JSON only, no schema (2025)
+            "gemini-2.0-flash-lite-001"     # 🟡 JSON only, no schema (2025)
           ].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
+            convert_dspy_schema_to_gemini(output_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
+            STRUCTURED_OUTPUT_MODELS.any? { |supported| base_model.start_with?(supported) }
           end
 
           sig { params(schema: T::Hash[Symbol, T.untyped]).returns(T::Array[String]) }
@@ -81,6 +66,8 @@ module DSPy
 
           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: {},
@@ -101,6 +88,21 @@ module DSPy
 
           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" }

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

@@ -13,14 +13,24 @@ module DSPy
         
         @structured_outputs_enabled = structured_outputs
         
+        # Disable streaming for VCR tests since SSE responses don't record properly
+        @use_streaming = true
+        begin
+          @use_streaming = false if defined?(VCR) && VCR.current_cassette
+        rescue
+          # If VCR 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
+            api_key: api_key,
+            version: 'v1beta'  # Use beta API version for structured outputs support
           },
           options: { 
             model: model,
-            server_sent_events: true
+            server_sent_events: @use_streaming
           }
         )
       end
@@ -43,33 +53,47 @@ module DSPy
         }.merge(extra_params)
 
         begin
-          # Always use streaming
           content = ""
           final_response_data = nil
           
-          @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}"
+          # 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
-            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?
+              # 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)
             
-            # Store final response data (usage, metadata) from last chunk
-            if chunk['usageMetadata'] || chunk.dig('candidates', 0, 'finishReason')
-              final_response_data = chunk
+            # 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