dspy 0.34.2 → 0.34.4

data/lib/dspy/re_act.rb

@@ -33,21 +33,6 @@ module DSPy
       }
     end
   end
-  # Base class for ReAct thought generation - will be customized per input type
-  class ThoughtBase < DSPy::Signature
-    description "Generate a thought about what to do next to process the given inputs."
-
-    output do
-      const :thought, String,
-        description: "Reasoning about what to do next, considering the history and observations."
-      const :action, String,
-        description: "The action to take. MUST be one of the tool names listed in `available_tools` input, or the literal string \"finish\" to provide the final answer."
-      const :tool_input, ToolInput,
-        description: "Input for the chosen tool action. Required when action is a tool name. MUST be a JSON object matching the tool's parameter schema. Set to null when action is \"finish\"."
-      const :final_answer, T.nilable(String),
-        description: "The final answer to return. Required when action is \"finish\". Must match the expected output type. Set to null when action is a tool name."
-    end
-  end
 
   class NextStep < T::Enum
     enums do
@@ -56,25 +41,62 @@ module DSPy
     end
   end
 
-  # Base class for observation processing - will be customized per input type
-  class ReActObservationBase < DSPy::Signature
-    description "Process the observation from a tool and decide what to do next."
-
-    output do
-      const :interpretation, String,
-        description: "Interpretation of the observation"
-      const :next_step, NextStep,
-        description: "What to do next: '#{NextStep::Continue}' or '#{NextStep::Finish}'"
-    end
-  end
-
   # ReAct Agent using Sorbet signatures
   class ReAct < Predict
     extend T::Sig
     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
 
@@ -228,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) }
@@ -280,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
@@ -298,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],
@@ -322,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
@@ -335,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,
@@ -419,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
@@ -443,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]
@@ -490,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({
@@ -516,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) }
@@ -559,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)
 
@@ -599,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
@@ -649,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(
@@ -666,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),
@@ -677,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),
@@ -692,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?
@@ -701,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
 
@@ -731,113 +796,6 @@ module DSPy
       end
     end
 
-    # Checks if a type is a scalar (primitives that don't need special serialization)
-    sig { params(type_object: T.untyped).returns(T::Boolean) }
-    def scalar_type?(type_object)
-      case type_object
-      when T::Types::Simple
-        scalar_classes = [String, Integer, Float, Numeric, TrueClass, FalseClass]
-        scalar_classes.any? { |klass| type_object.raw_type == klass || type_object.raw_type <= klass }
-      when T::Types::Union
-        # Union is scalar if all its types are scalars
-        type_object.types.all? { |t| scalar_type?(t) }
-      else
-        false
-      end
-    end
-
-    # Checks if a type is structured (arrays, hashes, structs that need type preservation)
-    sig { params(type_object: T.untyped).returns(T::Boolean) }
-    def structured_type?(type_object)
-      return true if type_object.is_a?(T::Types::TypedArray)
-      return true if type_object.is_a?(T::Types::TypedHash)
-
-      if type_object.is_a?(T::Types::Simple)
-        raw_type = type_object.raw_type
-        return true if raw_type.respond_to?(:<=) && raw_type <= T::Struct
-      end
-
-      # For union types (like T.nilable(T::Array[...])), check if any non-nil type is structured
-      if type_object.is_a?(T::Types::Union)
-        non_nil_types = type_object.types.reject { |t| t.is_a?(T::Types::Simple) && t.raw_type == NilClass }
-        return non_nil_types.any? { |t| structured_type?(t) }
-      end
-
-      false
-    end
-
-    # Checks if a type is String or compatible with String (e.g., T.any(String, ...) or T.nilable(String))
-    sig { params(type_object: T.untyped).returns(T::Boolean) }
-    def string_type?(type_object)
-      case type_object
-      when T::Types::Simple
-        type_object.raw_type == String
-      when T::Types::Union
-        # Check if any of the union types is String
-        type_object.types.any? { |t| t.is_a?(T::Types::Simple) && t.raw_type == String }
-      else
-        false
-      end
-    end
-
-    # Alias for backward compatibility
-    alias string_compatible_type? string_type?
-
-    # Get a readable type name from a Sorbet type object
-    sig { params(type_object: T.untyped).returns(String) }
-    def type_name(type_object)
-      case type_object
-      when T::Types::TypedArray
-        element_type = type_object.type
-        "T::Array[#{type_name(element_type)}]"
-      when T::Types::TypedHash
-        "T::Hash"
-      when T::Types::Simple
-        type_object.raw_type.to_s
-      when T::Types::Union
-        types_str = type_object.types.map { |t| type_name(t) }.join(', ')
-        "T.any(#{types_str})"
-      else
-        type_object.to_s
-      end
-    end
-
-    # Returns an appropriate default value for a given Sorbet type
-    # This is used when max iterations is reached without a successful completion
-    sig { params(type_object: T.untyped).returns(T.untyped) }
-    def default_value_for_type(type_object)
-      # Handle TypedArray (T::Array[...])
-      if type_object.is_a?(T::Types::TypedArray)
-        return []
-      end
-
-      # Handle TypedHash (T::Hash[...])
-      if type_object.is_a?(T::Types::TypedHash)
-        return {}
-      end
-
-      # Handle simple types
-      case type_object
-      when T::Types::Simple
-        raw_type = type_object.raw_type
-        case raw_type.to_s
-        when 'String' then ''
-        when 'Integer' then 0
-        when 'Float' then 0.0
-        when 'TrueClass', 'FalseClass' then false
-        else
-          # For T::Struct types, return nil as fallback
-          nil
-        end
-      when T::Types::Union
-        # For unions, return nil (assuming it's nilable) or first non-nil default
-        nil
-      else
-        # Default fallback for unknown types
-        nil
-      end
-    end
-
     # Tool execution method
     sig { params(action: String, tool_input: ToolInput).returns(T.untyped) }
     def execute_action(action, tool_input)
@@ -855,34 +813,6 @@ module DSPy
       end
     end
 
-    sig { params(output: T.untyped).void }
-    def validate_output_schema!(output)
-      # Validate that output is an instance of the enhanced output struct
-      unless output.is_a?(@enhanced_output_struct)
-        raise "Output must be an instance of #{@enhanced_output_struct}, got #{output.class}"
-      end
-
-      # Validate original signature output fields are present
-      @original_signature_class.output_struct_class.props.each do |field_name, _prop|
-        unless output.respond_to?(field_name)
-          raise "Missing required field: #{field_name}"
-        end
-      end
-
-      # Validate ReAct-specific fields
-      unless output.respond_to?(:history) && output.history.is_a?(Array)
-        raise "Missing or invalid history field"
-      end
-
-      unless output.respond_to?(:iterations) && output.iterations.is_a?(Integer)
-        raise "Missing or invalid iterations field"
-      end
-
-      unless output.respond_to?(:tools_used) && output.tools_used.is_a?(Array)
-        raise "Missing or invalid tools_used field"
-      end
-    end
-
     sig { override.returns(T::Hash[Symbol, T.untyped]) }
     def generate_example_output
       example = super
@@ -900,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
@@ -923,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/registry/signature_registry.rb

@@ -259,7 +259,7 @@ module DSPy
           emit_register_complete_event(signature_version)
           signature_version
 
-        rescue => error
+        rescue StandardError => error
           emit_register_error_event(signature_name, version, error)
           raise
         end
@@ -313,7 +313,7 @@ module DSPy
           emit_deploy_complete_event(deployed_version)
           deployed_version
 
-        rescue => error
+        rescue StandardError => error
           emit_deploy_error_event(signature_name, version, error)
           nil
         end
@@ -363,7 +363,7 @@ module DSPy
           emit_rollback_error_event(signature_name, "No previous version to rollback to")
           nil
 
-        rescue => error
+        rescue StandardError => error
           emit_rollback_error_event(signature_name, error.message)
           nil
         end

data/lib/dspy/ruby_llm/lm/adapters/ruby_llm_adapter.rb

@@ -52,7 +52,7 @@ module DSPy
             # Validate vision support if images are present
             if contains_images?(normalized_messages)
               validate_vision_support!
-              normalized_messages = format_multimodal_messages(normalized_messages)
+              normalized_messages = format_multimodal_messages(normalized_messages, provider)
             end
 
             chat_instance = create_chat_instance
@@ -358,32 +358,6 @@ module DSPy
             # If DSPy doesn't know about the model, let RubyLLM handle it
             # RubyLLM has its own model registry with capability detection
           end
-
-          def format_multimodal_messages(messages)
-            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'
-                    # Validate and format image for provider
-                    image = item[:image]
-                    if image.respond_to?(:validate_for_provider!)
-                      image.validate_for_provider!(provider)
-                    end
-                    item
-                  else
-                    item
-                  end
-                end
-
-                { role: msg[:role], content: formatted_content }
-              else
-                msg
-              end
-            end
-          end
         end
       end
     end

data/lib/dspy/schema/sorbet_json_schema.rb

@@ -195,10 +195,10 @@ module DSPy
             end
           else
             # Not nilable SimplePairUnion - this is a regular T.any() union
-            # Generate oneOf schema for all types
+            # Generate anyOf schema for all types (oneOf not supported by Anthropic strict mode)
             if type.respond_to?(:types) && type.types.length > 1
               {
-                oneOf: type.types.map { |t| type_to_json_schema_internal(t, visited, definitions) },
+                anyOf: type.types.map { |t| type_to_json_schema_internal(t, visited, definitions) },
                 description: "Union of multiple types"
               }
             else
@@ -237,14 +237,14 @@ module DSPy
             # Non-nilable single type union (shouldn't happen in practice)
             type_to_json_schema_internal(non_nil_types.first, visited, definitions)
           elsif non_nil_types.size > 1
-            # Handle complex unions with oneOf for better JSON schema compliance
+            # Handle complex unions with anyOf (oneOf not supported by Anthropic strict mode)
             base_schema = {
-              oneOf: non_nil_types.map { |t| type_to_json_schema_internal(t, visited, definitions) },
+              anyOf: non_nil_types.map { |t| type_to_json_schema_internal(t, visited, definitions) },
               description: "Union of multiple types"
             }
             if is_nilable
               # Add null as an option for complex nilable unions
-              base_schema[:oneOf] << { type: "null" }
+              base_schema[:anyOf] << { type: "null" }
             end
             base_schema
           else
@@ -335,7 +335,8 @@ module DSPy
           type: "object",
           properties: properties,
           required: required,
-          description: "#{struct_name} struct"
+          description: "#{struct_name} struct",
+          additionalProperties: false
         }
 
         # Add this struct's schema to definitions for $defs

data/lib/dspy/schema/version.rb

@@ -2,6 +2,6 @@
 
 module DSPy
   module Schema
-    VERSION = "1.0.0"
+    VERSION = "1.0.2"
   end
 end

data/lib/dspy/schema_adapters.rb

@@ -46,7 +46,7 @@ module DSPy
         begin
           result = from_hash(struct_class, hash_data)
           [true, result]
-        rescue => e
+        rescue StandardError => e
           [false, [e.message]]
         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