dspy 0.29.1 → 0.30.1

data/lib/dspy/context.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'securerandom'
+require 'json'
 
 module DSPy
   class Context
@@ -32,7 +33,8 @@ module DSPy
         context = {
           trace_id: SecureRandom.uuid,
           span_stack: [],
-          otel_span_stack: []
+          otel_span_stack: [],
+          module_stack: []
         }
         
         # Set in both Thread and Fiber storage
@@ -47,14 +49,15 @@ module DSPy
         span_id = SecureRandom.uuid
         parent_span_id = current[:span_stack].last
         start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        
+        sanitized_attributes = sanitize_span_attributes(attributes)
+
         # Prepare attributes with context information
         span_attributes = {
           trace_id: current[:trace_id],
           span_id: span_id,
           parent_span_id: parent_span_id,
           operation: operation,
-          **attributes
+          **sanitized_attributes
         }
         
         # Log span start with proper hierarchy (internal logging only)
@@ -67,7 +70,7 @@ module DSPy
           # Use OpenTelemetry's proper context management for nesting
           if DSPy::Observability.enabled? && DSPy::Observability.tracer
             # Prepare attributes and add trace name for root spans
-            span_attributes = attributes.transform_keys(&:to_s).reject { |k, v| v.nil? }
+            span_attributes = sanitized_attributes.transform_keys(&:to_s).reject { |k, v| v.nil? }
             
             # Set trace name if this is likely a root span (no parent in our stack)
             if current[:span_stack].length == 1  # This will be the first span
@@ -156,6 +159,48 @@ module DSPy
           end
         end
       end
+
+      def with_module(module_instance, label: nil)
+        stack = module_stack
+        entry = build_module_entry(module_instance, label)
+        stack.push(entry)
+        yield
+      ensure
+        if stack.last.equal?(entry)
+          stack.pop
+        else
+          stack.delete(entry)
+        end
+      end
+
+      def module_stack
+        current[:module_stack] ||= []
+      end
+
+      def module_context_attributes
+        stack = module_stack
+        return {} if stack.empty?
+
+        path = stack.map do |entry|
+          {
+            id: entry[:id],
+            class: entry[:class],
+            label: entry[:label]
+          }
+        end
+
+        ancestry_token = path.map { |node| node[:id] }.join('>')
+
+        {
+          module_path: path,
+          module_root: path.first,
+          module_leaf: path.last,
+          module_scope: {
+            ancestry_token: ancestry_token,
+            depth: path.length
+          }
+        }
+      end
       
       def clear!
         # Clear both the thread-specific key and the legacy key
@@ -173,6 +218,57 @@ module DSPy
       rescue
         false
       end
+
+      def sanitize_span_attributes(attributes)
+        attributes.each_with_object({}) do |(key, value), acc|
+          sanitized_value = sanitize_attribute_value(value)
+          acc[key] = sanitized_value
+        end
+      end
+
+      def sanitize_attribute_value(value)
+        case value
+        when nil, String, Integer, Float, TrueClass, FalseClass
+          value
+        when Time
+          value.iso8601(3)
+        when Array
+          begin
+            JSON.generate(value.map { |item| sanitize_attribute_value(item) })
+          rescue StandardError
+            value.map(&:to_s).to_s
+          end
+        when Hash
+          begin
+            sanitized_hash = value.each_with_object({}) do |(k, v), hash|
+              sanitized = sanitize_attribute_value(v)
+              hash[k.to_s] = sanitized unless sanitized.nil?
+            end
+            JSON.generate(sanitized_hash)
+          rescue StandardError
+            value.to_s
+          end
+        else
+          if defined?(T::Struct) && value.is_a?(T::Struct)
+            begin
+              struct_hash = value.to_h.transform_keys(&:to_s).transform_values { |v| sanitize_attribute_value(v) }
+              JSON.generate(struct_hash)
+            rescue StandardError
+              value.to_s
+            end
+          else
+            value.respond_to?(:to_json) ? value.to_json : value.to_s
+          end
+        end
+      end
+
+      def build_module_entry(module_instance, explicit_label)
+        {
+          id: (module_instance.respond_to?(:module_scope_id) ? module_instance.module_scope_id : SecureRandom.uuid),
+          class: module_instance.class.name,
+          label: explicit_label || (module_instance.respond_to?(:module_scope_label) ? module_instance.module_scope_label : nil)
+        }
+      end
     end
   end
-end
+end

data/lib/dspy/errors.rb

@@ -28,4 +28,22 @@ module DSPy
       MESSAGE
     end
   end
-end
+
+  class InstructionUpdateError < Error
+    def self.missing_instruction_capability(module_class)
+      new(<<~MESSAGE)
+        #{module_class} must implement `with_instruction(new_instruction)` to support DSPy teleprompters.
+
+        Update the module to return a new instance with the provided instruction, or opt out of teleprompter optimizers.
+      MESSAGE
+    end
+
+    def self.missing_examples_capability(module_class)
+      new(<<~MESSAGE)
+        #{module_class} must implement `with_examples(few_shot_examples)` to support DSPy teleprompters.
+
+        Update the module to return a new instance with the provided examples, or opt out of example optimization flows.
+      MESSAGE
+    end
+  end
+end

data/lib/dspy/{datasets.rb → evals/version.rb}

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 
-require_relative 'datasets/ade'
-
 module DSPy
-  module Datasets
+  class Evals
+    VERSION = '1.0.0'
   end
 end