dspy 0.34.1 → 0.34.3

data/lib/dspy/evals.rb

@@ -254,25 +254,7 @@ module DSPy
     # Evaluate program on a single example
     sig { params(example: T.untyped, trace: T.nilable(T.untyped)).returns(EvaluationResult) }
     def call(example, trace: nil)
-      run_callbacks(:before, :call, example: example)
-
-      DSPy::Context.with_span(
-        operation: 'evaluation.example',
-        'dspy.module' => 'Evaluator',
-        'evaluation.program' => @program.class.name,
-        'evaluation.has_metric' => !@metric.nil?
-      ) do
-        begin
-          perform_call(example, trace: trace)
-        rescue => e
-          build_error_result(example, e, trace: trace)
-        end
-      end.then do |result|
-        @last_example_result = result
-        emit_example_observation(example, result)
-        run_callbacks(:after, :call, example: example, result: result)
-        result
-      end
+      call_with_program(@program, example, trace: trace, track_state: true)
     end
 
     # Evaluate program on multiple examples
@@ -403,8 +385,9 @@ module DSPy
 
         futures = batch.map do |item|
           Concurrent::Promises.future_on(executor) do
-            [:ok, item[:index], safe_call(item[:example])]
-          rescue => e
+            program_for_thread = fork_program_for_thread
+            [:ok, item[:index], safe_call(item[:example], program: program_for_thread, track_state: false)]
+          rescue StandardError => e
             [:error, item[:index], e]
           end
         end
@@ -441,18 +424,18 @@ module DSPy
       results.compact
     end
 
-    def safe_call(example)
-      call(example)
-    rescue => e
+    def safe_call(example, program: @program, track_state: true)
+      call_with_program(program, example, track_state: track_state)
+    rescue StandardError => e
       build_error_result(example, e)
     end
 
-    def perform_call(example, trace:)
+    def perform_call(example, trace:, program:)
       # Extract input from example - support both hash and object formats
       input_values = extract_input_values(example)
 
       # Run prediction
-      prediction = @program.call(**input_values)
+      prediction = program.call(**input_values)
 
       # Calculate metrics if provided
       metrics = {}
@@ -469,7 +452,7 @@ module DSPy
             passed = !!metric_result
             metrics[:passed] = passed
           end
-        rescue => e
+        rescue StandardError => e
           passed = false
           metrics[:error] = e.message
           metrics[:passed] = false
@@ -490,6 +473,34 @@ module DSPy
       )
     end
 
+    def call_with_program(program, example, trace: nil, track_state: true)
+      run_callbacks(:before, :call, example: example)
+
+      DSPy::Context.with_span(
+        operation: 'evaluation.example',
+        'dspy.module' => 'Evaluator',
+        'evaluation.program' => program.class.name,
+        'evaluation.has_metric' => !@metric.nil?
+      ) do
+        begin
+          perform_call(example, trace: trace, program: program)
+        rescue StandardError => e
+          build_error_result(example, e, trace: trace)
+        end
+      end.then do |result|
+        @last_example_result = result if track_state
+        emit_example_observation(example, result)
+        run_callbacks(:after, :call, example: example, result: result)
+        result
+      end
+    end
+
+    def fork_program_for_thread
+      return @program if @program.nil?
+      return @program.dup_for_thread if @program.respond_to?(:dup_for_thread)
+      @program.dup
+    end
+
     def build_error_result(example, error, trace: nil)
       metrics = {
         error: error.message,
@@ -680,7 +691,7 @@ module DSPy
       if @export_scores
         export_example_score(example, result)
       end
-    rescue => e
+    rescue StandardError => e
       DSPy.log('evals.example.observation_error', error: e.message)
     end
 
@@ -698,7 +709,7 @@ module DSPy
       if @export_scores
         export_batch_score(batch_result)
       end
-    rescue => e
+    rescue StandardError => e
       DSPy.log('evals.batch.observation_error', error: e.message)
     end
 
@@ -711,7 +722,7 @@ module DSPy
         score_value,
         comment: "Example: #{example_id || 'unknown'}, passed: #{result.passed}"
       )
-    rescue => e
+    rescue StandardError => e
       DSPy.log('evals.score_export_error', error: e.message)
     end
 
@@ -721,7 +732,7 @@ module DSPy
         batch_result.pass_rate,
         comment: "Batch: #{batch_result.passed_examples}/#{batch_result.total_examples} passed"
       )
-    rescue => e
+    rescue StandardError => e
       DSPy.log('evals.batch_score_export_error', error: e.message)
     end
 

data/lib/dspy/events.rb

@@ -11,7 +11,6 @@ module DSPy
   class EventRegistry
     def initialize
       @listeners = {}
-      @subscription_counter = 0
       @mutex = Mutex.new
     end
 
@@ -53,7 +52,7 @@ module DSPy
       matching_listeners.each do |id, listener|
         begin
           listener[:block].call(event_name, attributes)
-        rescue => e
+        rescue StandardError => e
           # Log the error but continue processing other listeners
           # Use emit_log directly to avoid infinite recursion
           DSPy.send(:emit_log, 'event.listener.error', {
@@ -80,4 +79,4 @@ module DSPy
       end
     end
   end
-end
+end

data/lib/dspy/example.rb

@@ -178,7 +178,7 @@ module DSPy
             id: example_data[:id] || "example_#{index}"
           )
           examples << example
-        rescue => e
+        rescue StandardError => e
           errors << "Example #{index}: #{e.message}"
         end
       end

data/lib/dspy/lm/adapter.rb

@@ -57,6 +57,45 @@ module DSPy
           content.is_a?(Array) && content.any? { |item| item[:type] == 'image' }
         end
       end
+
+      # Format multimodal messages for a specific provider
+      # @param messages [Array<Hash>] Array of message hashes
+      # @param provider_name [String] Provider name for image validation and formatting
+      # @return [Array<Hash>] Messages with images formatted for the provider
+      def format_multimodal_messages(messages, provider_name)
+        messages.map do |msg|
+          if msg[:content].is_a?(Array)
+            formatted_content = msg[:content].map do |item|
+              case item[:type]
+              when 'text'
+                { type: 'text', text: item[:text] }
+              when 'image'
+                format_image_for_provider(item[:image], provider_name)
+              else
+                item
+              end
+            end
+            { role: msg[:role], content: formatted_content }
+          else
+            msg
+          end
+        end
+      end
+
+      # Format an image for a specific provider
+      # @param image [DSPy::Image] The image to format
+      # @param provider_name [String] Provider name (openai, anthropic, gemini, etc.)
+      # @return [Hash] Provider-specific image format
+      def format_image_for_provider(image, provider_name)
+        image.validate_for_provider!(provider_name)
+        format_method = "to_#{provider_name}_format"
+        if image.respond_to?(format_method)
+          image.send(format_method)
+        else
+          # For providers without specific format methods, return the item as-is
+          { type: 'image', image: image }
+        end
+      end
     end
   end
 end

data/lib/dspy/lm/json_strategy.rb

@@ -136,19 +136,54 @@ module DSPy
       end
 
       # Convert signature to Anthropic tool schema
+      # Uses strict: true for constrained decoding (Anthropic structured outputs)
+      # Anthropic strict mode requires ALL properties in required at every level.
       sig { returns(T::Hash[Symbol, T.untyped]) }
       def convert_to_anthropic_tool_schema
         output_fields = signature_class.output_field_descriptors
 
-        {
+        schema = {
           name: "json_output",
           description: "Output the result in the required JSON format",
+          strict: true,
           input_schema: {
             type: "object",
             properties: build_properties_from_fields(output_fields),
-            required: output_fields.keys.map(&:to_s)
+            required: build_required_from_fields(output_fields),
+            additionalProperties: false
           }
         }
+
+        # Anthropic strict mode: ALL properties must be in required at every level.
+        # Non-required properties get auto-wrapped in null unions by the grammar compiler,
+        # which counts against the 16-union-parameter limit.
+        enforce_all_required(schema[:input_schema])
+
+        schema
+      end
+
+      # Build required field list, excluding fields that have defaults
+      sig { params(fields: T::Hash[Symbol, T.untyped]).returns(T::Array[String]) }
+      def build_required_from_fields(fields)
+        fields.reject { |_name, descriptor| descriptor.has_default }.keys.map(&:to_s)
+      end
+
+      # Recursively enforce that all properties are in required and
+      # additionalProperties is false, as required by Anthropic strict mode.
+      sig { params(schema: T::Hash[Symbol, T.untyped]).void }
+      def enforce_all_required(schema)
+        return unless schema.is_a?(Hash)
+
+        if schema[:type] == "object" && schema[:properties]
+          schema[:required] = schema[:properties].keys.map(&:to_s)
+          schema[:additionalProperties] = false
+          schema[:properties].each_value { |v| enforce_all_required(v) }
+        elsif schema[:type] == "array" && schema[:items]
+          enforce_all_required(schema[:items])
+        elsif schema[:type].is_a?(Array)
+          # type: ["array", "null"] — check items if present
+          enforce_all_required(schema[:items]) if schema[:items]
+        end
       end
 
       # Build JSON schema properties from output fields

data/lib/dspy/lm/message.rb

@@ -154,7 +154,7 @@ module DSPy
           content: formatted_content,
           name: data[:name]&.to_s
         )
-      rescue => e
+      rescue StandardError => e
         DSPy.logger.debug("Failed to create Message: #{e.message}")
         nil
       end

data/lib/dspy/lm/response.rb

@@ -182,7 +182,7 @@ module DSPy
         else
           ResponseMetadata.new(**common_fields)
         end
-      rescue => e
+      rescue StandardError => e
         DSPy.logger.debug("Failed to create response metadata: #{e.message}")
         # Fallback to basic metadata
         ResponseMetadata.new(

data/lib/dspy/lm/usage.rb

@@ -99,7 +99,7 @@ module DSPy
           prompt_tokens_details: prompt_details,
           completion_tokens_details: completion_details
         )
-      rescue => e
+      rescue StandardError => e
         DSPy.logger.debug("Failed to create OpenAI usage: #{e.message}")
         nil
       end
@@ -133,7 +133,7 @@ module DSPy
           output_tokens: output_tokens,
           total_tokens: total_tokens
         )
-      rescue => e
+      rescue StandardError => e
         DSPy.logger.debug("Failed to create Anthropic usage: #{e.message}")
         nil
       end
@@ -150,7 +150,7 @@ module DSPy
           output_tokens: output_tokens,
           total_tokens: total_tokens
         )
-      rescue => e
+      rescue StandardError => e
         DSPy.logger.debug("Failed to create Gemini usage: #{e.message}")
         nil
       end
@@ -167,7 +167,7 @@ module DSPy
           output_tokens: output_tokens,
           total_tokens: total_tokens
         )
-      rescue => e
+      rescue StandardError => e
         DSPy.logger.debug("Failed to create generic usage: #{e.message}")
         nil
       end

data/lib/dspy/lm.rb

@@ -42,15 +42,11 @@ module DSPy
 
     def chat(inference_module, input_values, &block)
       # Capture the current DSPy context before entering Sync block
-      parent_context = DSPy::Context.current.dup
+      parent_context = DSPy::Context.current
       
       Sync do
-        # Properly restore the context in the new fiber created by Sync
-        # We need to set both thread and fiber storage for the new context system
-        thread_key = :"dspy_context_#{Thread.current.object_id}"
-        Thread.current[thread_key] = parent_context
-        Thread.current[:dspy_context] = parent_context  # Keep for backward compatibility
-        Fiber[:dspy_context] = parent_context
+        # Isolate fiber context while preserving trace/module ancestry
+        Fiber[:dspy_context] = DSPy::Context.fork_context(parent_context)
         
         signature_class = inference_module.signature_class
         
@@ -136,29 +132,6 @@ module DSPy
       response
     end
 
-    # Determines if LM-level events should be emitted using smart consolidation
-    def should_emit_lm_events?
-      # Emit LM events only if we're not in a nested context (smart consolidation)
-      !is_nested_context?
-    end
-
-    # Determines if we're in a nested context where higher-level events are being emitted
-    def is_nested_context?
-      caller_locations = caller_locations(1, 30)
-      return false if caller_locations.nil?
-      
-      # Look for higher-level DSPy modules in the call stack
-      # We consider ChainOfThought and ReAct as higher-level modules
-      higher_level_modules = caller_locations.select do |loc|
-        loc.path.include?('chain_of_thought') || 
-        loc.path.include?('re_act') ||
-        loc.path.include?('react')
-      end
-      
-      # If we have higher-level modules in the call stack, we're in a nested context
-      higher_level_modules.any?
-    end
-
     def parse_model_id(model_id)
       unless model_id.include?('/')
         raise ArgumentError, "model_id must include provider (e.g., 'openai/gpt-4', 'anthropic/claude-3'). Legacy format without provider is no longer supported."
@@ -173,7 +146,7 @@ module DSPy
 
       # Determine if structured outputs will be used and wrap prompt if so
       base_prompt = inference_module.prompt
-      prompt = if will_use_structured_outputs?(inference_module.signature_class)
+      prompt = if will_use_structured_outputs?(inference_module.signature_class, data_format: base_prompt.data_format)
         StructuredOutputsPrompt.new(**base_prompt.to_h)
       else
         base_prompt
@@ -198,8 +171,9 @@ module DSPy
       messages
     end
 
-    def will_use_structured_outputs?(signature_class)
+    def will_use_structured_outputs?(signature_class, data_format: nil)
       return false unless signature_class
+      return false if data_format == :toon
 
       adapter_class_name = adapter.class.name
 
@@ -354,8 +328,9 @@ module DSPy
         })
         
         # Add timing and request correlation if available
-        request_id = Thread.current[:dspy_request_id]
-        start_time = Thread.current[:dspy_request_start_time]
+        context = DSPy::Context.current
+        request_id = context[:request_id]
+        start_time = context[:request_start_time]
         
         if request_id
           event_attributes['request_id'] = request_id
@@ -411,53 +386,21 @@ module DSPy
       end
     end
 
-    public
-
-    def validate_messages!(messages)
-      unless messages.is_a?(Array)
-        raise ArgumentError, "messages must be an array"
-      end
-      
-      messages.each_with_index do |message, index|
-        # Accept both Message objects and hash format for backward compatibility
-        if message.is_a?(Message)
-          # Already validated by type system
-          next
-        elsif message.is_a?(Hash) && message.key?(:role) && message.key?(:content)
-          # Legacy hash format - validate role
-          valid_roles = %w[system user assistant]
-          unless valid_roles.include?(message[:role])
-            raise ArgumentError, "Invalid role at index #{index}: #{message[:role]}. Must be one of: #{valid_roles.join(', ')}"
-          end
-        else
-          raise ArgumentError, "Message at index #{index} must be a Message object or hash with :role and :content"
-        end
-      end
-    end
-
     def execute_raw_chat(messages, &streaming_block)
       # Generate unique request ID for tracking
       request_id = SecureRandom.hex(8)
       start_time = Time.now
-      
-      # Store request context for correlation
-      Thread.current[:dspy_request_id] = request_id
-      Thread.current[:dspy_request_start_time] = start_time
-      
-      begin
+
+      DSPy::Context.with_request(request_id, start_time) do
         response = instrument_lm_request(messages, 'RawPrompt') do
           # Convert messages to hash format for adapter
           hash_messages = messages_to_hash_array(messages)
           # Direct adapter call, no strategies or JSON parsing
           adapter.chat(messages: hash_messages, signature: nil, &streaming_block)
         end
-        
+
         # Return raw response content, not parsed JSON
         response.content
-      ensure
-        # Clean up thread-local storage
-        Thread.current[:dspy_request_id] = nil
-        Thread.current[:dspy_request_start_time] = nil
       end
     end
     
@@ -475,23 +418,28 @@ module DSPy
       messages.each_with_index do |msg, index|
         if msg.is_a?(Message)
           normalized << msg
-        elsif msg.is_a?(Hash)
-          # Validate hash has required fields
-          unless msg.key?(:role) && msg.key?(:content)
+        elsif msg.is_a?(Hash) || msg.respond_to?(:to_h)
+          data = msg.is_a?(Hash) ? msg : msg.to_h
+          unless data.is_a?(Hash)
+            raise ArgumentError, "Message at index #{index} must be a Message object or hash with :role and :content"
+          end
+
+          normalized_hash = data.transform_keys(&:to_sym)
+          unless normalized_hash.key?(:role) && normalized_hash.key?(:content)
             raise ArgumentError, "Message at index #{index} must have :role and :content"
           end
-          
-          # Validate role
+
+          role = normalized_hash[:role].to_s
           valid_roles = %w[system user assistant]
-          unless valid_roles.include?(msg[:role])
-            raise ArgumentError, "Invalid role at index #{index}: #{msg[:role]}. Must be one of: #{valid_roles.join(', ')}"
+          unless valid_roles.include?(role)
+            raise ArgumentError, "Invalid role at index #{index}: #{normalized_hash[:role]}. Must be one of: #{valid_roles.join(', ')}"
           end
-          
-          # Create Message object
-          message = MessageFactory.create(msg)
+
+          message = MessageFactory.create(normalized_hash)
           if message.nil?
             raise ArgumentError, "Failed to create Message from hash at index #{index}"
           end
+
           normalized << message
         else
           raise ArgumentError, "Message at index #{index} must be a Message object or hash with :role and :content"