dspy 0.27.0 → 0.27.2

data/lib/dspy/observability.rb

@@ -15,6 +15,13 @@ module DSPy
         public_key = ENV['LANGFUSE_PUBLIC_KEY']
         secret_key = ENV['LANGFUSE_SECRET_KEY']
         
+        # Skip OTLP configuration in test environment UNLESS Langfuse credentials are explicitly provided
+        # This allows observability tests to run while protecting general tests from network calls
+        if (ENV['RACK_ENV'] == 'test' || ENV['RAILS_ENV'] == 'test' || defined?(RSpec)) && !(public_key && secret_key)
+          DSPy.log('observability.disabled', reason: 'Test environment detected - OTLP disabled')
+          return
+        end
+        
         unless public_key && secret_key
           return
         end

data/lib/dspy/predict.rb

@@ -131,46 +131,32 @@ module DSPy
       with_prompt(@prompt.add_examples(examples))
     end
 
-    sig { override.params(kwargs: T.untyped).returns(T.type_parameter(:O)) }
-    def forward(**kwargs)
-      @last_input_values = kwargs.clone
-      T.cast(forward_untyped(**kwargs), T.type_parameter(:O))
-    end
+    # Remove forward override to let Module#forward handle span creation
 
     sig { params(input_values: T.untyped).returns(T.untyped) }
     def forward_untyped(**input_values)
-      # Wrap prediction in span tracking
-      DSPy::Context.with_span(
-        operation: "#{self.class.name}.forward",
-        'langfuse.observation.type' => 'span',
-        'langfuse.observation.input' => input_values.to_json,
-        'dspy.module' => self.class.name,
-        'dspy.signature' => @signature_class.name
-      ) do |span|
-        # Validate input
-        validate_input_struct(input_values)
-        
-        # Check if LM is configured
-        current_lm = lm
-        if current_lm.nil?
-          raise DSPy::ConfigurationError.missing_lm(self.class.name)
-        end
-        
-        # Call LM and process response
-        output_attributes = current_lm.chat(self, input_values)
-        processed_output = process_lm_output(output_attributes)
-        
-        # Create combined result struct
-        prediction_result = create_prediction_result(input_values, processed_output)
-        
-        # Add output to span
-        if span && prediction_result
-          output_hash = prediction_result.respond_to?(:to_h) ? prediction_result.to_h : prediction_result.to_s
-          span.set_attribute('langfuse.observation.output', DSPy::Utils::Serialization.to_json(output_hash))
-        end
-        
-        prediction_result
+      # Module#forward handles span creation, we just do the prediction logic
+      
+      # Store input values for optimization
+      @last_input_values = input_values.clone
+      
+      # Validate input
+      validate_input_struct(input_values)
+      
+      # Check if LM is configured
+      current_lm = lm
+      if current_lm.nil?
+        raise DSPy::ConfigurationError.missing_lm(self.class.name)
       end
+      
+      # Call LM and process response
+      output_attributes = current_lm.chat(self, input_values)
+      processed_output = process_lm_output(output_attributes)
+      
+      # Create combined result struct
+      prediction_result = create_prediction_result(input_values, processed_output)
+      
+      prediction_result
     end
 
     private

data/lib/dspy/re_act.rb

@@ -241,9 +241,10 @@ module DSPy
     # Executes a single iteration of the ReAct loop
     sig { params(input_struct: T.untyped, history: T::Array[HistoryEntry], available_tools_desc: T::Array[T::Hash[String, T.untyped]], iteration: Integer, tools_used: T::Array[String], last_observation: T.nilable(String)).returns(T::Hash[Symbol, T.untyped]) }
     def execute_single_iteration(input_struct, history, available_tools_desc, iteration, tools_used, last_observation)
-      # Track each iteration with span
+      # Track each iteration with agent span
       DSPy::Context.with_span(
         operation: 'react.iteration',
+        **DSPy::ObservationType::Agent.langfuse_attributes,
         'dspy.module' => 'ReAct',
         'react.iteration' => iteration,
         'react.max_iterations' => @max_iterations,
@@ -355,6 +356,7 @@ module DSPy
       if action && @tools[action.downcase]
         DSPy::Context.with_span(
           operation: 'react.tool_call',
+          **DSPy::ObservationType::Tool.langfuse_attributes,
           'dspy.module' => 'ReAct',
           'react.iteration' => iteration,
           'tool.name' => action.downcase,
@@ -419,7 +421,7 @@ module DSPy
 
     sig { params(iteration: Integer, thought: String, action: String, action_input: T.untyped, observation: String, tools_used: T::Array[String]).void }
     def emit_iteration_complete_event(iteration, thought, action, action_input, observation, tools_used)
-      DSPy.log('react.iteration_complete', **{
+      DSPy.event('react.iteration_complete', {
         'react.iteration' => iteration,
         'react.thought' => thought,
         'react.action' => action,
@@ -432,7 +434,7 @@ module DSPy
     sig { params(iterations_count: Integer, final_answer: T.nilable(String), tools_used: T::Array[String], history: T::Array[HistoryEntry]).void }
     def handle_max_iterations_if_needed(iterations_count, final_answer, tools_used, history)
       if iterations_count >= @max_iterations && final_answer.nil?
-        DSPy.log('react.max_iterations', **{
+        DSPy.event('react.max_iterations', {
           'react.iteration_count' => iterations_count,
           'react.max_iterations' => @max_iterations,
           'react.tools_used' => tools_used.uniq,

data/lib/dspy/tools/base.rb

@@ -2,6 +2,8 @@
 
 require 'sorbet-runtime'
 require 'json'
+require_relative '../type_system/sorbet_json_schema'
+require_relative '../mixins/type_coercion'
 
 module DSPy
   module Tools
@@ -9,6 +11,7 @@ module DSPy
     class Base
       extend T::Sig
       extend T::Helpers
+      include DSPy::Mixins::TypeCoercion
 
       class << self
         extend T::Sig
@@ -30,14 +33,14 @@ module DSPy
 
         # Get the JSON schema for the call method based on its Sorbet signature
         sig { returns(T::Hash[Symbol, T.untyped]) }
-        def call_schema
+        def call_schema_object
           method_obj = instance_method(:call)
           sig_info = T::Utils.signature_for_method(method_obj)
 
           if sig_info.nil?
             # Fallback for methods without signatures
             return {
-              type: :object,
+              type: "object",
               properties: {},
               required: []
             }
@@ -50,10 +53,8 @@ module DSPy
           sig_info.arg_types.each do |param_name, param_type|
             next if param_name == :block # Skip block parameters
 
-            properties[param_name] = {
-              type: sorbet_type_to_json_schema(param_type)[:type],
-              description: "Parameter #{param_name}"
-            }
+            schema = DSPy::TypeSystem::SorbetJsonSchema.type_to_json_schema(param_type)
+            properties[param_name] = schema.merge({ description: "Parameter #{param_name}" })
 
             # Check if parameter is required (not nilable)
             unless param_type.class.name.include?('Union') && param_type.name.include?('NilClass')
@@ -65,10 +66,8 @@ module DSPy
           sig_info.kwarg_types.each do |param_name, param_type|
             next if param_name == :block # Skip block parameters
 
-            properties[param_name] = {
-              type: sorbet_type_to_json_schema(param_type)[:type],
-              description: "Parameter #{param_name}"
-            }
+            schema = DSPy::TypeSystem::SorbetJsonSchema.type_to_json_schema(param_type)
+            properties[param_name] = schema.merge({ description: "Parameter #{param_name}" })
 
             # Check if parameter is required by looking at required kwarg names
             if sig_info.req_kwarg_names.include?(param_name)
@@ -79,54 +78,25 @@ module DSPy
           end
 
           {
-            type: :object,
+            type: "object",
             properties: properties,
             required: required
           }
         end
 
-        private
-
-        # Convert Sorbet types to JSON Schema types
-        sig { params(sorbet_type: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
-        def sorbet_type_to_json_schema(sorbet_type)
-          if sorbet_type.is_a?(T::Types::Simple)
-            raw_type = sorbet_type.raw_type
-
-            if raw_type == String
-              { type: :string }
-            elsif raw_type == Integer
-              { type: :integer }
-            elsif raw_type == Float
-              { type: :number }
-            elsif raw_type == Numeric
-              { type: :number }
-            elsif raw_type == TrueClass || raw_type == FalseClass
-              { type: :boolean }
-            elsif raw_type == T::Boolean
-              { type: :boolean }
-            else
-              { type: :string, description: "#{raw_type} (converted to string)" }
-            end
-          elsif sorbet_type.is_a?(T::Types::Union)
-            # Handle nilable types
-            non_nil_types = sorbet_type.types.reject { |t| t == T::Utils.coerce(NilClass) }
-            if non_nil_types.length == 1
-              result = sorbet_type_to_json_schema(non_nil_types.first)
-              result[:description] = "#{result[:description] || ''} (optional)".strip
-              result
-            else
-              { type: :string, description: "Union type (converted to string)" }
-            end
-          elsif sorbet_type.is_a?(T::Types::TypedArray)
-            {
-              type: :array,
-              items: sorbet_type_to_json_schema(sorbet_type.type)
+        # Get the full tool schema for LLM tools format
+        sig { returns(T::Hash[Symbol, T.untyped]) }
+        def call_schema
+          {
+            type: 'function',
+            function: {
+              name: 'call',
+              description: "Call the #{self.name} tool",
+              parameters: call_schema_object
             }
-          else
-            { type: :string, description: "#{sorbet_type} (converted to string)" }
-          end
+          }
         end
+
       end
 
       # Instance methods that tools can use
@@ -143,7 +113,7 @@ module DSPy
       # Get the JSON schema string for the tool, formatted for LLM consumption
       sig { returns(String) }
       def schema
-        schema_obj = self.class.call_schema
+        schema_obj = self.class.call_schema_object
         tool_info = {
           name: name,
           description: description,
@@ -152,11 +122,17 @@ module DSPy
         JSON.generate(tool_info)
       end
 
+      # Get the full call schema compatible with LLM tools format
+      sig { returns(T::Hash[Symbol, T.untyped]) }
+      def call_schema
+        self.class.call_schema
+      end
+
       # Dynamic call method for ReAct agent - parses JSON arguments and calls the typed method
       sig { params(args_json: T.untyped).returns(T.untyped) }
       def dynamic_call(args_json)
         # Parse arguments based on the call schema
-        schema = self.class.call_schema
+        schema = self.class.call_schema_object
 
         if schema[:properties].empty?
           # No parameters - call without arguments
@@ -178,12 +154,34 @@ module DSPy
 
           # Convert string keys to symbols and validate types
           kwargs = {}
-          schema[:properties].each do |param_name, param_schema|
-            key = param_name.to_s
-            if args.key?(key)
-              kwargs[param_name] = convert_argument_type(args[key], param_schema)
-            elsif schema[:required].include?(key)
-              return "Error: Missing required parameter: #{key}"
+          
+          # Get method signature for type information
+          method_obj = self.class.instance_method(:call)
+          sig_info = T::Utils.signature_for_method(method_obj)
+          
+          if sig_info
+            # Handle kwargs using type signature information
+            sig_info.kwarg_types.each do |param_name, param_type|
+              next if param_name == :block
+              
+              key = param_name.to_s
+              if args.key?(key)
+                kwargs[param_name] = coerce_value_to_type(args[key], param_type)
+              elsif schema[:required].include?(key)
+                return "Error: Missing required parameter: #{key}"
+              end
+            end
+            
+            # Handle positional args if any
+            sig_info.arg_types.each do |param_name, param_type|
+              next if param_name == :block
+              
+              key = param_name.to_s
+              if args.key?(key)
+                kwargs[param_name] = coerce_value_to_type(args[key], param_type)
+              elsif schema[:required].include?(key)
+                return "Error: Missing required parameter: #{key}"
+              end
             end
           end
 
@@ -195,32 +193,6 @@ module DSPy
 
       # Subclasses must implement their own call method with their own signature
 
-      protected
-
-      # Convert argument to the expected type based on JSON schema
-      sig { params(value: T.untyped, schema: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
-      def convert_argument_type(value, schema)
-        case schema[:type]
-        when :integer
-          value.is_a?(Integer) ? value : value.to_i
-        when :number
-          # Always convert to Float for :number types to ensure compatibility with strict Float signatures
-          value.to_f
-        when :boolean
-          case value
-          when true, false
-            value
-          when "true", "1", 1
-            true
-          when "false", "0", 0
-            false
-          else
-            !!value
-          end
-        else
-          value.to_s
-        end
-      end
     end
   end
 end