dspy 0.34.3 → 1.0.0

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/ruby_llm/lm/adapters/ruby_llm_adapter.rb

@@ -5,9 +5,6 @@ require 'ruby_llm'
 require 'dspy/lm/adapter'
 require 'dspy/lm/vision_models'
 
-require 'dspy/ruby_llm/guardrails'
-DSPy::RubyLLM::Guardrails.ensure_ruby_llm_installed!
-
 module DSPy
   module RubyLLM
     module LM
@@ -49,6 +46,8 @@ module DSPy
           def chat(messages:, signature: nil, &block)
             normalized_messages = normalize_messages(messages)
 
+            validate_document_support!(normalized_messages)
+
             # Validate vision support if images are present
             if contains_images?(normalized_messages)
               validate_vision_support!
@@ -255,6 +254,9 @@ module DSPy
                   elsif item[:image_url]
                     attachments << item[:image_url][:url]
                   end
+                when 'document'
+                  document = item[:document]
+                  attachments << document.to_ruby_llm_attachment if document
                 end
               end
               content = text_parts.join("\n")
@@ -263,6 +265,14 @@ module DSPy
             [content.to_s, attachments]
           end
 
+          def validate_document_support!(messages)
+            return unless contains_documents?(messages)
+            return if provider == 'anthropic'
+
+            raise DSPy::LM::IncompatibleDocumentFeatureError,
+                  "RubyLLM document inputs are currently supported only when the underlying provider is Anthropic."
+          end
+
           def map_response(ruby_llm_response)
             DSPy::LM::Response.new(
               content: ruby_llm_response.content.to_s,

data/lib/dspy/ruby_llm/version.rb

@@ -2,6 +2,6 @@
 
 module DSPy
   module RubyLLM
-    VERSION = '0.1.0'
+    VERSION = '0.1.1'
   end
 end

data/lib/dspy/ruby_llm.rb

@@ -2,7 +2,4 @@
 
 require 'dspy/ruby_llm/version'
 
-require 'dspy/ruby_llm/guardrails'
-DSPy::RubyLLM::Guardrails.ensure_ruby_llm_installed!
-
 require 'dspy/ruby_llm/lm/adapters/ruby_llm_adapter'

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/support/openai_sdk_warning.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module DSPy
+  module Support
+    module OpenAISDKWarning
+      WARNING_MESSAGE = <<~WARNING.freeze
+        WARNING: ruby-openai gem detected. This may cause conflicts with DSPy's OpenAI integration.
+
+        DSPy uses the official 'openai' gem. The community 'ruby-openai' gem uses the same
+        OpenAI namespace and will cause conflicts.
+
+        To fix this, remove 'ruby-openai' from your Gemfile and use the official gem instead:
+        - Remove: gem 'ruby-openai'
+        - Keep: gem 'openai' (official SDK that DSPy uses)
+
+        The official gem provides better compatibility and is actively maintained by OpenAI.
+      WARNING
+
+      def self.warn_if_community_gem_loaded!
+        return if @warned
+        return unless community_gem_loaded?
+
+        Kernel.warn WARNING_MESSAGE
+        @warned = true
+      end
+
+      def self.community_gem_loaded?
+        defined?(::OpenAI) && defined?(::OpenAI::Client) && !defined?(::OpenAI::Internal)
+      end
+    end
+  end
+end

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 = "1.0.0"
 end

data/lib/dspy.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require_relative 'dspy/support/warning_filters'
+require_relative 'dspy/support/openai_sdk_warning'
 require 'sorbet-runtime'
 require 'dry-configurable'
 require 'dry/logger'
@@ -159,13 +160,61 @@ module DSPy
       if value.is_a?(Hash)
         flatten_attributes(value, new_key, result)
       else
-        result[new_key] = value
+        result[new_key] = sanitize_event_attribute_value(value)
       end
     end
 
     result
   end
 
+  def self.sanitize_event_attribute_value(value)
+    return value if primitive_event_attribute_value?(value)
+
+    if value.is_a?(Array)
+      return value if homogeneous_primitive_array?(value)
+      return JSON.generate(value.map { |item| normalize_event_json_value(item) })
+    end
+
+    if value.is_a?(Hash)
+      return JSON.generate(normalize_event_json_value(value))
+    end
+
+    if value.respond_to?(:to_h)
+      return JSON.generate(normalize_event_json_value(value.to_h))
+    end
+
+    value.respond_to?(:to_json) ? value.to_json : value.to_s
+  rescue StandardError
+    value.to_s
+  end
+
+  def self.primitive_event_attribute_value?(value)
+    value.nil? || value.is_a?(String) || value.is_a?(Integer) || value.is_a?(Float) || value.is_a?(TrueClass) || value.is_a?(FalseClass)
+  end
+
+  def self.homogeneous_primitive_array?(value)
+    return true if value.empty?
+    return false unless value.all? { |item| primitive_event_attribute_value?(item) }
+
+    value.map(&:class).uniq.size == 1
+  end
+
+  def self.normalize_event_json_value(value)
+    if primitive_event_attribute_value?(value)
+      value
+    elsif value.is_a?(Array)
+      value.map { |item| normalize_event_json_value(item) }
+    elsif value.is_a?(Hash)
+      value.each_with_object({}) do |(k, v), acc|
+        acc[k.to_s] = normalize_event_json_value(v)
+      end
+    elsif value.respond_to?(:to_h)
+      normalize_event_json_value(value.to_h)
+    else
+      value.to_s
+    end
+  end
+
   def self.create_logger
     env = ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
     log_output = ENV['DSPY_LOG'] # Allow override
@@ -219,6 +268,7 @@ require_relative 'dspy/prompt'
 require_relative 'dspy/example'
 require_relative 'dspy/lm'
 require_relative 'dspy/image'
+require_relative 'dspy/document'
 require_relative 'dspy/prediction'
 require_relative 'dspy/predict'
 require_relative 'dspy/chain_of_thought'
@@ -261,19 +311,4 @@ DSPy::Observability.configure!
 
 # LoggerSubscriber will be lazy-initialized when first accessed
 
-# Detect potential gem conflicts and warn users
-# DSPy uses the official openai gem, warn if ruby-openai (community version) is detected
-if defined?(OpenAI) && defined?(OpenAI::Client) && !defined?(OpenAI::Internal)
-  warn <<~WARNING
-    WARNING: ruby-openai gem detected. This may cause conflicts with DSPy's OpenAI integration.
-    
-    DSPy uses the official 'openai' gem. The community 'ruby-openai' gem uses the same
-    OpenAI namespace and will cause conflicts.
-    
-    To fix this, remove 'ruby-openai' from your Gemfile and use the official gem instead:
-    - Remove: gem 'ruby-openai'
-    - Keep: gem 'openai' (official SDK that DSPy uses)
-    
-    The official gem provides better compatibility and is actively maintained by OpenAI.
-  WARNING
-end
+DSPy::Support::OpenAISDKWarning.warn_if_community_gem_loaded!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.34.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
@@ -100,6 +100,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -107,6 +110,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.5.1
 - !ruby/object:Gem::Dependency
   name: sorbet-toon
   requirement: !ruby/object:Gem::Requirement
@@ -151,6 +157,7 @@ files:
 - lib/dspy/callbacks.rb
 - lib/dspy/chain_of_thought.rb
 - lib/dspy/context.rb
+- lib/dspy/document.rb
 - lib/dspy/error_formatter.rb
 - lib/dspy/errors.rb
 - lib/dspy/evals.rb
@@ -188,7 +195,6 @@ files:
 - lib/dspy/registry/registry_manager.rb
 - lib/dspy/registry/signature_registry.rb
 - lib/dspy/ruby_llm.rb
-- lib/dspy/ruby_llm/guardrails.rb
 - lib/dspy/ruby_llm/lm/adapters/ruby_llm_adapter.rb
 - lib/dspy/ruby_llm/version.rb
 - lib/dspy/schema.rb
@@ -204,6 +210,7 @@ files:
 - lib/dspy/storage/program_storage.rb
 - lib/dspy/storage/storage_manager.rb
 - lib/dspy/structured_outputs_prompt.rb
+- lib/dspy/support/openai_sdk_warning.rb
 - lib/dspy/support/warning_filters.rb
 - lib/dspy/teleprompt/bootstrap_strategy.rb
 - lib/dspy/teleprompt/data_handler.rb

data/lib/dspy/ruby_llm/guardrails.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'dspy/lm/errors'
-
-module DSPy
-  module RubyLLM
-    class Guardrails
-      SUPPORTED_RUBY_LLM_VERSIONS = "~> 1.3".freeze
-
-      def self.ensure_ruby_llm_installed!
-        require 'ruby_llm'
-
-        spec = Gem.loaded_specs["ruby_llm"]
-        unless spec && Gem::Requirement.new(SUPPORTED_RUBY_LLM_VERSIONS).satisfied_by?(spec.version)
-          msg = <<~MSG
-            DSPy requires the `ruby_llm` gem #{SUPPORTED_RUBY_LLM_VERSIONS}.
-            Please install or upgrade it with `bundle add ruby_llm --version "#{SUPPORTED_RUBY_LLM_VERSIONS}"`.
-          MSG
-          raise DSPy::LM::UnsupportedVersionError, msg
-        end
-      end
-    end
-  end
-end