dspy 0.27.1 → 0.27.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7962564b749798c462b3202e16153aa9e508e8d7fb10d6618c76e740ecb171d1
-  data.tar.gz: d81fad4637c82967745d644c291f7436e26c0c1bf06785ff56028c71d4d5f26d
+  metadata.gz: d697eb8eb574ca5c23914c1911f1d7a03ad7411aa83b19bedf2231cacc544460
+  data.tar.gz: 3086cbaa86d01b0dd09512c9f5893f8a31b8d9988eed6782a967c24e1c12fb01
 SHA512:
-  metadata.gz: 38ed78b62481f7267a9d1fa7157af436bdfd82d6a8281b00b9d8915fa74e7b0b5d896f8dfa9d6f4a91aa829973f7db94445d76b3cdb5e7c66800cd23f28f1fe9
-  data.tar.gz: 61f0ef47790c3c9aa6c6ecd1f7ee11268ac81b27ca75212af2c69b4f4b077fa07c9acb237c7d7b3f4174c85d7de415684ac9fef5c88e01d538671b93910fa889
+  metadata.gz: eae9e4cba177e6cea359f1ffd55ebaa4203cc5a6594b86ab5fc2b9b9e8c54cf24838a8d18102ab96fc9a8f4b85827c3cb02ef0b75c3d077c6c70301abb52f48d
+  data.tar.gz: ecc26be5f85df66e911a71d5a1fa878cc42c79c7d63e42b2d1440836859814837f4ba782db18584161598867a5aef5ebbfef056a2988b4208767b8e0c1999013

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,31 +6,41 @@ module DSPy
   class Context
     class << self
       def current
-        # Use a combination of Thread and Fiber storage for proper context management
-        # Thread storage ensures thread isolation
-        # Fiber storage ensures OpenTelemetry context propagation
+        # 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}"
         
-        # Check if this thread has its own context
+        # Always check thread-local storage first for proper isolation
         if Thread.current[thread_key]
-          # Thread has context, ensure fiber has it too for OpenTelemetry
-          Fiber[:dspy_context] ||= Thread.current[thread_key]
-        else
-          # No context for this thread - create new one
-          context = {
-            trace_id: SecureRandom.uuid,
-            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
+          # 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
         
-        # Return the context (from Fiber storage for OpenTelemetry compatibility)
-        Fiber[:dspy_context]
+        # 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)
@@ -67,23 +77,66 @@ module DSPy
             # Record start time for explicit duration tracking
             otel_start_time = Time.now
             
-            # Always use in_span which properly manages context internally
-            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)

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

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "sorbet-runtime"
-require_relative "../../cache_manager"
 
 module DSPy
   class LM
@@ -22,22 +21,12 @@ module DSPy
 
           sig { params(signature_class: T.class_of(DSPy::Signature), name: T.nilable(String), strict: T::Boolean).returns(T::Hash[Symbol, T.untyped]) }
           def self.to_openai_format(signature_class, name: nil, strict: true)
-            # Build cache params from the method parameters
-            cache_params = { strict: strict }
-            cache_params[:name] = name if name
-            
-            # Check cache first
-            cache_manager = DSPy::LM.cache_manager
-            cached_schema = cache_manager.get_schema(signature_class, "openai", cache_params)
-            
-            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 oneOf to anyOf where safe, or raise error for unsupported cases
+            output_schema = convert_oneof_to_anyof_if_safe(output_schema)
+            
             # Build the complete schema with OpenAI-specific modifications
             dspy_schema = {
               "$schema": "http://json-schema.org/draft-06/schema#",
@@ -59,7 +48,7 @@ module DSPy
             end
 
             # Wrap in OpenAI's required format
-            result = {
+            {
               type: "json_schema",
               json_schema: {
                 name: schema_name,
@@ -67,34 +56,75 @@ module DSPy
                 schema: openai_schema
               }
             }
+          end
+
+          # Convert oneOf to anyOf if safe (discriminated unions), otherwise raise error
+          sig { params(schema: T.untyped).returns(T.untyped) }
+          def self.convert_oneof_to_anyof_if_safe(schema)
+            return schema unless schema.is_a?(Hash)
+            
+            result = schema.dup
+            
+            # Check if this schema has oneOf that we can safely convert
+            if result[:oneOf]
+              if all_have_discriminators?(result[:oneOf])
+                # Safe to convert - discriminators ensure mutual exclusivity
+                result[:anyOf] = result.delete(:oneOf).map { |s| convert_oneof_to_anyof_if_safe(s) }
+              else
+                # Unsafe conversion - raise error
+                raise DSPy::UnsupportedSchemaError.new(
+                  "OpenAI structured outputs do not support oneOf schemas without discriminator fields. " \
+                  "The schema contains union types that cannot be safely converted to anyOf. " \
+                  "Please use enhanced_prompting strategy instead or add discriminator fields to union types."
+                )
+              end
+            end
+            
+            # Recursively process nested schemas
+            if result[:properties].is_a?(Hash)
+              result[:properties] = result[:properties].transform_values { |v| convert_oneof_to_anyof_if_safe(v) }
+            end
             
-            # Cache the result with same params
-            cache_manager.cache_schema(signature_class, "openai", result, cache_params)
+            if result[:items].is_a?(Hash)
+              result[:items] = convert_oneof_to_anyof_if_safe(result[:items])
+            end
+            
+            # Process arrays of schema items
+            if result[:items].is_a?(Array)
+              result[:items] = result[:items].map { |item| 
+                item.is_a?(Hash) ? convert_oneof_to_anyof_if_safe(item) : item 
+              }
+            end
+            
+            # Process anyOf arrays (in case there are nested oneOf within anyOf)
+            if result[:anyOf].is_a?(Array)
+              result[:anyOf] = result[:anyOf].map { |item| 
+                item.is_a?(Hash) ? convert_oneof_to_anyof_if_safe(item) : item 
+              }
+            end
             
             result
           end
+          
+          # Check if all schemas in a oneOf array have discriminator fields (const properties)
+          sig { params(schemas: T::Array[T.untyped]).returns(T::Boolean) }
+          def self.all_have_discriminators?(schemas)
+            schemas.all? do |schema|
+              next false unless schema.is_a?(Hash)
+              next false unless schema[:properties].is_a?(Hash)
+              
+              # Check if any property has a const value (our discriminator pattern)
+              schema[:properties].any? { |_, prop| prop.is_a?(Hash) && prop[:const] }
+            end
+          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(/^openai\//, "")
             
             # 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]) }
@@ -226,8 +256,8 @@ module DSPy
               end
             end
             
-            # Process oneOf/anyOf/allOf
-            [:oneOf, :anyOf, :allOf].each do |key|
+            # Process anyOf/allOf (oneOf should be converted to anyOf by this point)
+            [:anyOf, :allOf].each do |key|
               if result[key].is_a?(Array)
                 result[key] = result[key].map do |sub_schema|
                   sub_schema.is_a?(Hash) ? add_additional_properties_recursively(sub_schema) : sub_schema
@@ -272,8 +302,8 @@ module DSPy
               max_depth = [max_depth, items_depth].max
             end
 
-            # Check oneOf/anyOf/allOf
-            [:oneOf, :anyOf, :allOf].each do |key|
+            # Check anyOf/allOf (oneOf should be converted to anyOf by this point)
+            [:anyOf, :allOf].each do |key|
               if schema[key].is_a?(Array)
                 schema[key].each do |sub_schema|
                   if sub_schema.is_a?(Hash)
@@ -291,8 +321,8 @@ module DSPy
           def self.contains_pattern_properties?(schema)
             return true if schema[:patternProperties]
 
-            # Recursively check nested schemas
-            [:properties, :items, :oneOf, :anyOf, :allOf].each do |key|
+            # Recursively check nested schemas (oneOf should be converted to anyOf by this point)
+            [:properties, :items, :anyOf, :allOf].each do |key|
               value = schema[key]
               case value
               when Hash
@@ -309,8 +339,8 @@ module DSPy
           def self.contains_conditional_schemas?(schema)
             return true if schema[:if] || schema[:then] || schema[:else]
 
-            # Recursively check nested schemas
-            [:properties, :items, :oneOf, :anyOf, :allOf].each do |key|
+            # Recursively check nested schemas (oneOf should be converted to anyOf by this point) 
+            [:properties, :items, :anyOf, :allOf].each do |key|
               value = schema[key]
               case value
               when Hash