dspy 0.34.3 → 0.34.4

data/lib/dspy/module.rb

@@ -261,21 +261,64 @@ module DSPy
     def instrument_forward_call(call_args, call_kwargs)
       ensure_module_subscriptions!
 
+      input_json = serialize_module_input(call_args, call_kwargs)
+      root_call = DSPy::Context.current[:span_stack].empty?
+
       DSPy::Context.with_module(self) do
         observation_type = DSPy::ObservationType.for_module_class(self.class)
         span_attributes = observation_type.langfuse_attributes.merge(
-          'langfuse.observation.input' => serialize_module_input(call_args, call_kwargs),
+          'langfuse.observation.input' => input_json,
           'dspy.module' => self.class.name
         )
+        operation_name = "#{self.class.name}.forward"
+        span_attributes.merge!(root_trace_attributes(call_args, call_kwargs, input_json)) if root_call
+
+        if self.class.name == 'DSPy::Predict' && respond_to?(:signature_class)
+          signature_name = signature_class&.name
+          span_attributes['dspy.signature'] = signature_name || 'anonymous'
+          span_attributes['dspy.signature_kind'] = infer_signature_kind(signature_name)
+          span_attributes['dspy.predictor_label'] = module_scope_label if module_scope_label
+          operation_name = "DSPy::Predict(#{signature_name}).forward" if signature_name
+        end
 
         DSPy::Context.with_span(
-          operation: "#{self.class.name}.forward",
+          operation: operation_name,
           **span_attributes
         ) do |span|
-          yield.tap do |result|
-            if span && result
-              span.set_attribute('langfuse.observation.output', serialize_module_output(result))
+          begin
+            yield.tap do |result|
+              if span && !result.nil?
+                span.set_attribute('langfuse.observation.output', serialize_module_output(result))
+                span.set_attribute('langfuse.observation.status', 'completed')
+                span.set_attribute('dspy.status', 'completed')
+                if root_call
+                  span.set_attribute('langfuse.trace.output', serialize_module_output(result))
+                  span.set_attribute('langfuse.trace.status', 'completed')
+                end
+              end
+            end
+          rescue StandardError => e
+            if span
+              span.set_attribute('langfuse.observation.output', serialize_module_error_output(e))
+              span.set_attribute('langfuse.observation.status', 'error')
+              span.set_attribute('dspy.error.class', e.class.name)
+              span.set_attribute('dspy.error.message', e.message.to_s[0, 2000]) if e.message
+              span.set_attribute('dspy.status', 'error')
+              if root_call
+                span.set_attribute('langfuse.trace.output', serialize_module_error_output(e))
+                span.set_attribute('langfuse.trace.status', 'error')
+              end
+              if e.respond_to?(:iterations)
+                span.set_attribute('dspy.error.iterations', e.iterations.to_i) unless e.iterations.nil?
+              end
+              if e.respond_to?(:max_iterations)
+                span.set_attribute('dspy.error.max_iterations', e.max_iterations.to_i) unless e.max_iterations.nil?
+              end
+              if e.respond_to?(:tools_used)
+                span.set_attribute('dspy.error.tools_used', Array(e.tools_used).map(&:to_s))
+              end
             end
+            raise
           end
         end
       end
@@ -303,7 +346,91 @@ module DSPy
       result.to_s
     end
 
-    private :instrument_forward_call, :serialize_module_input, :serialize_module_output
+    def serialize_module_error_output(error)
+      payload = {
+        error: {
+          class: error.class.name,
+          message: error.message.to_s
+        }
+      }
+
+      if error.respond_to?(:iterations) || error.respond_to?(:max_iterations) || error.respond_to?(:tools_used)
+        payload[:react] = {}
+        payload[:react][:iterations] = error.iterations if error.respond_to?(:iterations)
+        payload[:react][:max_iterations] = error.max_iterations if error.respond_to?(:max_iterations)
+        payload[:react][:tools_used] = Array(error.tools_used) if error.respond_to?(:tools_used)
+      end
+
+      serialized = DSPy::TypeSerializer.serialize(payload)
+      JSON.generate(serialized)
+    rescue StandardError
+      "#{error.class}: #{error.message}"
+    end
+
+    def root_trace_attributes(call_args, call_kwargs, input_json)
+      metadata = {
+        module: self.class.name,
+        signature: (respond_to?(:signature_class) ? signature_class&.name : nil),
+        signature_kind: (respond_to?(:signature_class) ? infer_signature_kind(signature_class&.name) : nil),
+        predictor_label: module_scope_label
+      }.compact
+      conversation_id, conversation_id_source = resolve_conversation_id(call_args, call_kwargs)
+      metadata[:conversation_id_source] = conversation_id_source if conversation_id_source
+
+      {
+        'langfuse.trace.name' => "#{self.class.name}.forward",
+        'langfuse.trace.input' => input_json,
+        'langfuse.trace.metadata' => JSON.generate(metadata),
+        'langfuse.trace.output' => '{"status":"in_progress"}',
+        'conversation_id' => conversation_id,
+        'dspy.conversation_id' => conversation_id
+      }
+    rescue StandardError
+      {}
+    end
+
+    # Conversation ID precedence is deterministic:
+    # 1. top-level kwargs[:conversation_id]
+    # 2. first positional hash arg[:conversation_id]
+    # 3. kwargs[:input_context][:conversation_id]
+    # 4. DSPy::Context.current[:conversation_id]
+    def resolve_conversation_id(call_args, call_kwargs)
+      direct = fetch_hash_value(call_kwargs, :conversation_id)
+      return [direct.to_s, 'kwargs.conversation_id'] if present_value?(direct)
+
+      first_arg = call_args.first if call_args.is_a?(Array) && call_args.first.is_a?(Hash)
+      arg_value = fetch_hash_value(first_arg, :conversation_id)
+      return [arg_value.to_s, 'args[0].conversation_id'] if present_value?(arg_value)
+
+      input_context = fetch_hash_value(call_kwargs, :input_context)
+      nested = fetch_hash_value(input_context, :conversation_id)
+      return [nested.to_s, 'kwargs.input_context.conversation_id'] if present_value?(nested)
+
+      context_value = fetch_hash_value(DSPy::Context.current, :conversation_id)
+      return [context_value.to_s, 'context.conversation_id'] if present_value?(context_value)
+
+      [nil, nil]
+    end
+
+    def fetch_hash_value(hash, key)
+      return nil unless hash.is_a?(Hash)
+
+      hash[key] || hash[key.to_s]
+    end
+
+    def present_value?(value)
+      !value.nil? && !(value.respond_to?(:empty?) && value.empty?)
+    end
+
+    def infer_signature_kind(signature_name)
+      return 'custom' unless signature_name
+      return 'thought' if signature_name.match?(/thought/i)
+      return 'observation' if signature_name.match?(/observation/i)
+
+      'custom'
+    end
+
+    private :instrument_forward_call, :serialize_module_input, :serialize_module_output, :serialize_module_error_output, :root_trace_attributes, :resolve_conversation_id, :fetch_hash_value, :present_value?, :infer_signature_kind
 
     sig { returns(String) }
     def module_scope_id

data/lib/dspy/predict.rb

@@ -304,7 +304,7 @@ module DSPy
         next unless prop_type
 
         # For nilable fields with nil values, ensure proper handling
-        if value.nil? && is_nilable_type?(prop_type)
+        if value.nil? && nilable_type?(prop_type)
           # For nilable fields, nil is valid - keep it as is
           next
         elsif value.nil? && prop_info[:fully_optional]

data/lib/dspy/prediction.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require_relative 'utils/serialization'
+
 module DSPy
   class Prediction
     extend T::Sig
@@ -54,7 +56,14 @@ module DSPy
 
     sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h
-      @_struct.serialize
+      hash = DSPy::Utils::Serialization.deep_serialize(@_struct.serialize)
+      hash.delete('_prediction_marker')
+      hash
+    end
+
+    sig { params(args: T.untyped).returns(String) }
+    def to_json(*args)
+      to_h.to_json(*args)
     end
 
     private

data/lib/dspy/prompt.rb

@@ -5,6 +5,7 @@ require 'sorbet-runtime'
 require 'sorbet/toon'
 
 require_relative 'few_shot_example'
+require_relative 'utils/serialization'
 require_relative 'schema/sorbet_toon_adapter'
 
 module DSPy
@@ -241,7 +242,7 @@ module DSPy
       else
         sections << "## Input Values"
         sections << "```json"
-        sections << JSON.pretty_generate(serialize_for_json(input_values))
+        sections << JSON.pretty_generate(DSPy::Utils::Serialization.deep_serialize(input_values))
         sections << "```"
         sections << ""
         sections << "Respond with the corresponding output schema fields wrapped in a ```json ``` block,"
@@ -376,51 +377,6 @@ module DSPy
       "# Please install: gem install sorbet-baml"
     end
 
-    # Recursively serialize complex objects for JSON representation
-    sig { params(obj: T.untyped).returns(T.untyped) }
-    def serialize_for_json(obj)
-      case obj
-      when T::Struct
-        # Convert T::Struct to hash using to_h method if available
-        if obj.respond_to?(:to_h)
-          serialize_for_json(obj.to_h)
-        else
-          # Fallback: serialize using struct properties
-          serialize_struct_to_hash(obj)
-        end
-      when Hash
-        # Recursively serialize hash values
-        obj.transform_values { |v| serialize_for_json(v) }
-      when Array
-        # Recursively serialize array elements
-        obj.map { |item| serialize_for_json(item) }
-      when T::Enum
-        # Serialize enums to their string representation
-        obj.serialize
-      else
-        # For basic types (String, Integer, Float, Boolean, etc.), return as-is
-        obj
-      end
-    end
-
-    # Fallback method to serialize T::Struct to hash when to_h is not available
-    sig { params(struct_obj: T::Struct).returns(T::Hash[Symbol, T.untyped]) }
-    def serialize_struct_to_hash(struct_obj)
-      result = {}
-      
-      # Use struct's props method to get all properties
-      if struct_obj.class.respond_to?(:props)
-        struct_obj.class.props.each do |prop_name, _prop_info|
-          if struct_obj.respond_to?(prop_name)
-            value = struct_obj.public_send(prop_name)
-            result[prop_name] = serialize_for_json(value)
-          end
-        end
-      end
-      
-      result
-    end
-
     def toon_data_format_enabled?
       data_format == :toon && @signature_class
     end

data/lib/dspy/re_act.rb

@@ -47,7 +47,56 @@ module DSPy
     include Mixins::StructBuilder
 
     # Custom error classes
-    class MaxIterationsError < StandardError; end
+    class MaxIterationsError < StandardError
+      extend T::Sig
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :iterations
+
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :max_iterations
+
+      sig { returns(T::Array[String]) }
+      attr_reader :tools_used
+
+      sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
+      attr_reader :history
+
+      sig { returns(T.untyped) }
+      attr_reader :last_observation
+
+      sig { returns(T.untyped) }
+      attr_reader :partial_final_answer
+
+      sig do
+        params(
+          message: String,
+          iterations: T.nilable(Integer),
+          max_iterations: T.nilable(Integer),
+          tools_used: T::Array[String],
+          history: T::Array[T::Hash[Symbol, T.untyped]],
+          last_observation: T.untyped,
+          partial_final_answer: T.untyped
+        ).void
+      end
+      def initialize(
+        message = "Agent reached maximum iterations without producing a final answer",
+        iterations: nil,
+        max_iterations: nil,
+        tools_used: [],
+        history: [],
+        last_observation: nil,
+        partial_final_answer: nil
+      )
+        @iterations = T.let(iterations, T.nilable(Integer))
+        @max_iterations = T.let(max_iterations, T.nilable(Integer))
+        @tools_used = T.let(tools_used, T::Array[String])
+        @history = T.let(history, T::Array[T::Hash[Symbol, T.untyped]])
+        @last_observation = last_observation
+        @partial_final_answer = partial_final_answer
+        super(message)
+      end
+    end
     class InvalidActionError < StandardError; end
     class TypeMismatchError < StandardError; end
 
@@ -201,19 +250,17 @@ module DSPy
 
     sig { params(input_struct: T.untyped).returns(T.untyped) }
     def format_input_context(input_struct)
-      return input_struct if toon_data_format?
-
-      DSPy::TypeSerializer.serialize(input_struct).to_json
+      input_struct
     end
 
     sig { params(history: T::Array[HistoryEntry]).returns(T.untyped) }
     def format_history(history)
-      toon_data_format? ? history : serialize_history_for_llm(history)
+      history
     end
 
     sig { params(observation: T.untyped).returns(T.untyped) }
     def format_observation(observation)
-      toon_data_format? ? observation : serialize_for_llm(observation)
+      observation
     end
 
     sig { returns(T::Boolean) }
@@ -253,11 +300,7 @@ module DSPy
     sig { params(signature_class: T.class_of(DSPy::Signature), data_format: Symbol).returns(T.class_of(DSPy::Signature)) }
     def create_thought_signature(signature_class, data_format)
       action_enum_class = @action_enum_class
-      input_context_type = if data_format == :toon
-        signature_class.input_struct_class || String
-      else
-        String
-      end
+      input_context_type = signature_class.input_struct_class || String
 
       # Get the output field type for the final_answer field
       output_field_name = signature_class.output_struct_class.props.keys.first
@@ -271,7 +314,7 @@ module DSPy
         # Define input fields
         input do
           const :input_context, input_context_type,
-            description: data_format == :toon ? "All original input fields with their typed values" : "Serialized representation of all input fields"
+            description: "All original input fields with their typed values"
           const :history, T::Array[HistoryEntry],
             description: "Previous thoughts and actions, including observations from tools."
           const :available_tools, T::Array[AvailableTool],
@@ -295,11 +338,7 @@ module DSPy
     # Creates a dynamic observation signature that includes the original input fields
     sig { params(signature_class: T.class_of(DSPy::Signature), data_format: Symbol).returns(T.class_of(DSPy::Signature)) }
     def create_observation_signature(signature_class, data_format)
-      input_context_type = if data_format == :toon
-        signature_class.input_struct_class || String
-      else
-        String
-      end
+      input_context_type = signature_class.input_struct_class || String
       # Create new class that inherits from DSPy::Signature
       Class.new(DSPy::Signature) do
         # Set description
@@ -308,7 +347,7 @@ module DSPy
         # Define input fields
         input do
           const :input_context, input_context_type,
-            description: data_format == :toon ? "All original input fields with their typed values" : "Serialized representation of all input fields"
+            description: "All original input fields with their typed values"
           const :history, T::Array[HistoryEntry],
             description: "Previous thoughts, actions, and observations."
           const :observation, T.untyped,
@@ -392,7 +431,7 @@ module DSPy
         if finish_action?(thought_obj.action)
           final_answer = handle_finish_action(
             thought_obj.final_answer, last_observation, iteration,
-            thought_obj.thought, thought_obj.action, history
+            thought_obj.thought, thought_obj.action, history, expected_output_field_type
           )
           return { should_finish: true, final_answer: final_answer }
         end
@@ -416,7 +455,7 @@ module DSPy
 
         # Process observation and decide next step
         observation_decision = process_observation_and_decide_next_step(
-          input_struct, history, observation, available_tools_desc, iteration
+          input_struct, history, observation, available_tools_desc, iteration, tools_used
         )
 
         if observation_decision[:should_finish]
@@ -463,7 +502,8 @@ module DSPy
       if final_answer.nil?
         iterations = reasoning_result[:iterations]
         tools_used = reasoning_result[:tools_used]
-        raise MaxIterationsError, "Agent reached maximum iterations (#{iterations}) without producing a final answer. Tools used: #{tools_used.join(', ')}"
+        history = T.cast(reasoning_result[:history], T::Array[HistoryEntry])
+        raise build_max_iterations_error(iterations: iterations, tools_used: tools_used, history: history)
       end
 
       output_data = input_kwargs.merge({
@@ -489,6 +529,19 @@ module DSPy
       history.reverse.find { |entry| !entry.observation.nil? }&.observation
     end
 
+    sig { params(iterations: Integer, tools_used: T::Array[String], history: T::Array[HistoryEntry], partial_final_answer: T.untyped).returns(MaxIterationsError) }
+    def build_max_iterations_error(iterations:, tools_used:, history:, partial_final_answer: nil)
+      MaxIterationsError.new(
+        "Agent reached maximum iterations (#{iterations}) without producing a final answer. Tools used: #{tools_used.join(', ')}",
+        iterations: iterations,
+        max_iterations: @max_iterations,
+        tools_used: tools_used.uniq,
+        history: history.map(&:to_h),
+        last_observation: find_last_tool_observation(history),
+        partial_final_answer: partial_final_answer
+      )
+    end
+
     # Deserialize final answer to match expected output type
     # Routes to appropriate deserialization based on type classification
     sig { params(final_answer: T.untyped, output_field_type: T.untyped, history: T::Array[HistoryEntry]).returns(T.untyped) }
@@ -532,6 +585,12 @@ module DSPy
         return last_tool_observation
       end
 
+      # Structured outputs frequently arrive as JSON strings; parse before coercion.
+      if final_answer.is_a?(String)
+        parsed = parse_json_string(final_answer)
+        final_answer = parsed unless parsed.nil?
+      end
+
       # If final_answer already matches, use it
       return final_answer if type_matches?(final_answer, output_field_type)
 
@@ -572,7 +631,11 @@ module DSPy
     def type_matches?(value, type_object)
       case type_object
       when T::Types::TypedArray
-        value.is_a?(Array) && (value.empty? || value.first.is_a?(T::Struct))
+        return false unless value.is_a?(Array)
+        return true if value.empty?
+
+        element_type = type_object.type
+        value.all? { |item| type_matches?(item, element_type) }
       when T::Types::TypedHash
         value.is_a?(Hash)
       when T::Types::Simple
@@ -622,12 +685,25 @@ module DSPy
         'dspy.module' => 'ReAct',
         'react.iteration' => iteration,
         'tool.name' => action_str.downcase,
+        'langfuse.observation.input' => serialize_tool_payload(tool_input),
         'tool.input' => tool_input
-      ) do
-        execute_action(action_str, tool_input)
+      ) do |span|
+        result = execute_action(action_str, tool_input)
+        if span
+          span.set_attribute('langfuse.observation.output', serialize_tool_payload(result))
+        end
+        result
       end
     end
 
+    sig { params(payload: T.untyped).returns(String) }
+    def serialize_tool_payload(payload)
+      serialized = DSPy::TypeSerializer.serialize(payload)
+      JSON.generate(serialized)
+    rescue StandardError
+      payload.to_s
+    end
+
     sig { params(step: Integer, thought: String, action: String, tool_input: ToolInput, observation: T.untyped).returns(HistoryEntry) }
     def create_history_entry(step, thought, action, tool_input, observation)
       HistoryEntry.new(
@@ -639,8 +715,8 @@ module DSPy
       )
     end
 
-    sig { params(input_struct: T.untyped, history: T::Array[HistoryEntry], observation: T.untyped, available_tools_desc: T::Array[AvailableTool], iteration: Integer).returns(T::Hash[Symbol, T.untyped]) }
-    def process_observation_and_decide_next_step(input_struct, history, observation, available_tools_desc, iteration)
+    sig { params(input_struct: T.untyped, history: T::Array[HistoryEntry], observation: T.untyped, available_tools_desc: T::Array[AvailableTool], iteration: Integer, tools_used: T::Array[String]).returns(T::Hash[Symbol, T.untyped]) }
+    def process_observation_and_decide_next_step(input_struct, history, observation, available_tools_desc, iteration, tools_used)
       observation_result = @observation_processor.forward(
         input_context: format_input_context(input_struct),
         history: format_history(history),
@@ -650,14 +726,14 @@ module DSPy
       return { should_finish: false } unless observation_result.next_step == NextStep::Finish
 
       final_answer = generate_forced_final_answer(
-        input_struct, history, available_tools_desc, observation_result, iteration
+        input_struct, history, available_tools_desc, observation_result, iteration, tools_used
       )
 
       { should_finish: true, final_answer: final_answer }
     end
 
-    sig { params(input_struct: T.untyped, history: T::Array[HistoryEntry], available_tools_desc: T::Array[AvailableTool], observation_result: T.untyped, iteration: Integer).returns(T.untyped) }
-    def generate_forced_final_answer(input_struct, history, available_tools_desc, observation_result, iteration)
+    sig { params(input_struct: T.untyped, history: T::Array[HistoryEntry], available_tools_desc: T::Array[AvailableTool], observation_result: T.untyped, iteration: Integer, tools_used: T::Array[String]).returns(T.untyped) }
+    def generate_forced_final_answer(input_struct, history, available_tools_desc, observation_result, iteration, tools_used)
       final_thought = @thought_generator.forward(
         input_context: format_input_context(input_struct),
         history: format_history(history),
@@ -665,6 +741,8 @@ module DSPy
       )
 
       action_str = final_thought.action.respond_to?(:serialize) ? final_thought.action.serialize : final_thought.action.to_s
+      output_field_type = expected_output_field_type
+
       if action_str.downcase != FINISH_ACTION
         # Use interpretation if available, otherwise use last observation
         forced_answer = if observation_result.interpretation && !observation_result.interpretation.empty?
@@ -674,9 +752,23 @@ module DSPy
                         else
                           raise MaxIterationsError, "Observation processor indicated finish but no answer is available"
                         end
-        handle_finish_action(forced_answer, history.last&.observation, iteration + 1, final_thought.thought, FINISH_ACTION, history)
+
+        if structured_type?(output_field_type)
+          coerced_forced_answer = coerce_candidate_for_output(forced_answer, output_field_type)
+          if coerced_forced_answer.nil?
+            raise build_max_iterations_error(
+              iterations: iteration,
+              tools_used: tools_used,
+              history: history,
+              partial_final_answer: forced_answer
+            )
+          end
+          handle_finish_action(coerced_forced_answer, history.last&.observation, iteration + 1, final_thought.thought, FINISH_ACTION, history, output_field_type)
+        else
+          handle_finish_action(forced_answer, history.last&.observation, iteration + 1, final_thought.thought, FINISH_ACTION, history, output_field_type)
+        end
       else
-        handle_finish_action(final_thought.final_answer, history.last&.observation, iteration + 1, final_thought.thought, final_thought.action, history)
+        handle_finish_action(final_thought.final_answer, history.last&.observation, iteration + 1, final_thought.thought, final_thought.action, history, output_field_type)
       end
     end
 
@@ -738,13 +830,14 @@ module DSPy
       example
     end
 
-    sig { params(final_answer_value: T.untyped, last_observation: T.untyped, step: Integer, thought: String, action: T.any(String, T::Enum), history: T::Array[HistoryEntry]).returns(T.untyped) }
-    def handle_finish_action(final_answer_value, last_observation, step, thought, action, history)
+    sig { params(final_answer_value: T.untyped, last_observation: T.untyped, step: Integer, thought: String, action: T.any(String, T::Enum), history: T::Array[HistoryEntry], output_field_type: T.untyped).returns(T.untyped) }
+    def handle_finish_action(final_answer_value, last_observation, step, thought, action, history, output_field_type)
       final_answer = final_answer_value
 
       # If final_answer is empty/nil but we have a last observation, use it
       if (final_answer.nil? || (final_answer.is_a?(String) && final_answer.empty?)) && last_observation
-        final_answer = last_observation
+        fallback_value = coerce_candidate_for_output(last_observation, output_field_type)
+        final_answer = fallback_value unless fallback_value.nil?
       end
 
       # Convert action enum to string for storage in history
@@ -761,5 +854,37 @@ module DSPy
 
       final_answer
     end
+
+    sig { returns(T.untyped) }
+    def expected_output_field_type
+      output_field_name = @original_signature_class.output_struct_class.props.keys.first
+      @original_signature_class.output_struct_class.props[output_field_name][:type_object]
+    end
+
+    sig { params(value: T.untyped, output_field_type: T.untyped).returns(T.untyped) }
+    def coerce_candidate_for_output(value, output_field_type)
+      return value if type_matches?(value, output_field_type)
+
+      candidate = value
+      if candidate.is_a?(String) && structured_type?(output_field_type)
+        parsed = parse_json_string(candidate)
+        candidate = parsed unless parsed.nil?
+      end
+
+      return candidate if type_matches?(candidate, output_field_type)
+
+      converted = convert_to_expected_type(candidate, output_field_type)
+      return converted if type_matches?(converted, output_field_type)
+
+      nil
+    end
+
+    sig { params(value: String).returns(T.nilable(T.untyped)) }
+    def parse_json_string(value)
+      parsed = JSON.parse(value)
+      parsed
+    rescue JSON::ParserError
+      nil
+    end
   end
 end

data/lib/dspy/signature.rb

@@ -58,11 +58,10 @@ module DSPy
         Class.new(T::Struct) do
           extend T::Sig
           descriptors.each do |name, descriptor|
-            if descriptor.has_default
-              const name, descriptor.type, default: descriptor.default_value
-            else
-              const name, descriptor.type
-            end
+            opts = {}
+            opts[:default] = descriptor.default_value if descriptor.has_default
+            opts[:description] = descriptor.description if descriptor.description
+            const name, descriptor.type, **opts
           end
         end
       end

data/lib/dspy/structured_outputs_prompt.rb

@@ -80,7 +80,7 @@ module DSPy
 
       sections << "## Input Values"
       sections << "```json"
-      sections << JSON.pretty_generate(serialize_for_json(input_values))
+      sections << JSON.pretty_generate(DSPy::Utils::Serialization.deep_serialize(input_values))
       sections << "```"
 
       sections.join("\n")

data/lib/dspy/utils/serialization.rb

@@ -13,6 +13,8 @@ module DSPy
         when T::Struct
           # Use the serialize method to convert to a plain hash
           deep_serialize(obj.serialize)
+        when T::Enum
+          obj.serialize
         when Hash
           # Recursively serialize hash values
           obj.transform_values { |v| deep_serialize(v) }
@@ -24,12 +26,6 @@ module DSPy
           obj
         end
       end
-
-      # Serializes an object to JSON with proper T::Struct handling
-      sig { params(obj: T.untyped).returns(String) }
-      def self.to_json(obj)
-        deep_serialize(obj).to_json
-      end
     end
   end
 end

data/lib/dspy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DSPy
-  VERSION = "0.34.3"
+  VERSION = "0.34.4"
 end