dspy 0.34.2 → 0.34.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7fe4cbffffd520f31219caa7dbce4b75ef39684cdd5e422b60144aa3ae3329e9
-  data.tar.gz: '0974465586686c0b93292b464f9b49abcb10a265ca85295c65584e989a271d7f'
+  metadata.gz: 01f38786c88d525a1031cf41931f578c3d2dcbfa29ee6a8dac1a381cafe47edf
+  data.tar.gz: 6334bfb483b3011fa91e163f688127be763a126ea7cd0edc44f07b0557dc2a30
 SHA512:
-  metadata.gz: 5602b8a59a8454306921a2528ccb58824cfe3878a4d31f3b8b4b93d94730c6f2e804c439a9fd1f7bb44a2afe6aff6cb3843e1d7ad6f45c51e4e01aec7d44db5c
-  data.tar.gz: 4bf2656ade52cbf55e6416a061e9107c9332a0e669b9bafe07acf045aac605eaa38410ae433268b78a7d285b47450e03e8416e9a456d978e258177fce00a90e9
+  metadata.gz: 744087dd87e936b247d194539407f2a74b29d5e6a28b4ba872c4aa0ef77103c4a6957c97b6bed3ee7e8ef899824f3e6e0f40c2b429c47312aa10924bb1fbca3c
+  data.tar.gz: 4e343687e84570d199ce9c7695d19d0a0a551cac66693fda131fe03268d3907e2d20f4648530d1e6a5de0a73092b03f3ec7bcec877d9c23662332193aaee0e31

data/lib/dspy/chain_of_thought.rb

@@ -47,7 +47,8 @@ module DSPy
         output_schema: @signature_class.output_json_schema,
         few_shot_examples: new_prompt.few_shot_examples,
         signature_class_name: @signature_class.name,
-        schema_format: new_prompt.schema_format
+        schema_format: new_prompt.schema_format,
+        data_format: new_prompt.data_format
       )
       
       instance.instance_variable_set(:@prompt, enhanced_prompt)
@@ -93,7 +94,7 @@ module DSPy
       
       # 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
+      predict_instance.configure { |c| c.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)

data/lib/dspy/context.rb

@@ -31,6 +31,18 @@ module DSPy
         context
       end
 
+      def with_request(request_id, start_time)
+        previous_request_id = current[:request_id]
+        previous_start_time = current[:request_start_time]
+
+        current[:request_id] = request_id
+        current[:request_start_time] = start_time
+        yield
+      ensure
+        current[:request_id] = previous_request_id
+        current[:request_start_time] = previous_start_time
+      end
+
       def fork_context(parent_context)
         clone_context(parent_context)
       end
@@ -216,7 +228,9 @@ module DSPy
           fiber_id: Fiber.current.object_id,
           span_stack: [],
           otel_span_stack: [],
-          module_stack: []
+          module_stack: [],
+          request_id: nil,
+          request_start_time: nil
         }
       end
 
@@ -227,6 +241,8 @@ module DSPy
         cloned[:module_stack] = Array(context[:module_stack]).map { |entry| entry.dup }
         cloned[:thread_id] = Thread.current.object_id
         cloned[:fiber_id] = Fiber.current.object_id
+        cloned[:request_id] = context[:request_id]
+        cloned[:request_start_time] = context[:request_start_time]
         cloned
       end
 

data/lib/dspy/evals/version.rb

@@ -2,6 +2,6 @@
 
 module DSPy
   class Evals
-    VERSION = '1.0.1'
+    VERSION = '1.0.2'
   end
 end

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

@@ -146,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
@@ -171,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
 
@@ -327,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
@@ -384,63 +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.respond_to?(:to_h)
-          data = message.is_a?(Hash) ? message : message.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 = data.transform_keys(&:to_sym)
-          unless normalized.key?(:role) && normalized.key?(:content)
-            raise ArgumentError, "Message at index #{index} must have :role and :content"
-          end
-
-          role = normalized[:role].to_s
-          valid_roles = %w[system user assistant]
-          unless valid_roles.include?(role)
-            raise ArgumentError, "Invalid role at index #{index}: #{normalized[: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