dspy 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7efcb1d5900858477fe538790a6d132a8e289260bb326cee5f30316358fa80f0
-  data.tar.gz: c4116d5f2e01e34e23b6bd3baefd5f7480af214284410c77255d4f37fc099743
+  metadata.gz: de6126089636bd0d5fdaf9cd2bba791157186683a7984174bac980be8e32a483
+  data.tar.gz: 1e78c20f7e1a37cf025158be0f4014ee2abe9ba95b84682361ff9ea544fecd2c
 SHA512:
-  metadata.gz: 487725527cfbe3b91d5694999aecdd6fe916940bb9ed42c2a222346b0f1b09ec7b9cb0bdf0f6509a542d72a07bfd4dab66dc879b6bf76d2dc1ebb7e61064dfa7
-  data.tar.gz: d3674ea0fe89d498d31b5be92e1a24458bfec0c79f55aef061869cf3a7014f2b5ab67ffac24226c6783f3ea0e485e16bdc16a1dafeef906f602241d8fd7077b7
+  metadata.gz: 7b3dbde7e5040dc1b0562142bdc560f9fc393bbb7cf20bef4d767541be079408dc1c6e196257f07193266713585bdfb21ac77bd08df3c6ab69607354393987c2
+  data.tar.gz: 412cf071635f85bb3fb08f339a1dce23d4a9f00144104fc03fc25cc706d87c86c707221bc8a98f6847a7e157e2fa86de8bee4ee7c44d2bd1b9b0ab41934dd411

data/README.md

@@ -43,7 +43,7 @@ The result? LLM applications that actually scale and don't break when you sneeze
 
 ## Development Status
 
-DSPy.rb is actively developed and approaching stability at **v0.9.0**. The core framework is production-ready with comprehensive documentation, but I'm battle-testing features through the 0.x series before committing to a stable v1.0 API. 
+DSPy.rb is actively developed and approaching stability at **v0.10.1**. The core framework is production-ready with comprehensive documentation, but I'm battle-testing features through the 0.x series before committing to a stable v1.0 API. 
 
 Real-world usage feedback is invaluable - if you encounter issues or have suggestions, please open a GitHub issue!
 
@@ -174,7 +174,7 @@ DSPy.rb has rapidly evolved from experimental to production-ready:
 
 ## Roadmap - Battle-Testing Toward v1.0
 
-DSPy.rb is currently at **v0.9.0** and approaching stability. I'm focusing on real-world usage and refinement through the 0.10, 0.11, 0.12+ series before committing to a stable v1.0 API.
+DSPy.rb is currently at **v0.10.1** and approaching stability. I'm focusing on real-world usage and refinement through the 0.11, 0.12+ series before committing to a stable v1.0 API.
 
 **Current Focus Areas:**
 - 🚧 **Ollama Support** - Local model integration

data/lib/dspy/errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module DSPy
+  class Error < StandardError; end
+  
+  class ValidationError < Error; end
+  
+  class DeserializationError < Error; end
+  
+  class ConfigurationError < Error
+    def self.missing_lm(module_name)
+      new(<<~MESSAGE)
+        No language model configured for #{module_name} module.
+
+        To fix this, configure a language model either globally:
+
+          DSPy.configure do |config|
+            config.lm = DSPy::LM.new("openai/gpt-4", api_key: ENV["OPENAI_API_KEY"])
+          end
+
+        Or on the module instance:
+
+          module_instance.configure do |config|
+            config.lm = DSPy::LM.new("anthropic/claude-3", api_key: ENV["ANTHROPIC_API_KEY"])
+          end
+      MESSAGE
+    end
+  end
+end

data/lib/dspy/example.rb

@@ -77,6 +77,17 @@ module DSPy
       expected_hash
     end
 
+    # Custom equality comparison
+    sig { params(other: T.untyped).returns(T::Boolean) }
+    def ==(other)
+      return false unless other.is_a?(Example)
+      
+      @signature_class == other.signature_class &&
+        input_values == other.input_values &&
+        expected_values == other.expected_values
+    end
+
+
     # Check if prediction matches expected output using struct comparison
     sig { params(prediction: T.untyped).returns(T::Boolean) }
     def matches_prediction?(prediction)
@@ -179,15 +190,6 @@ module DSPy
       examples
     end
 
-    # Equality comparison
-    sig { params(other: T.untyped).returns(T::Boolean) }
-    def ==(other)
-      return false unless other.is_a?(Example)
-      
-      @signature_class == other.signature_class &&
-        input_values == other.input_values &&
-        expected_values == other.expected_values
-    end
 
     # String representation for debugging
     sig { returns(String) }

data/lib/dspy/mixins/instrumentation_helpers.rb

@@ -15,6 +15,9 @@ module DSPy
       # Prepares base instrumentation payload for prediction-based modules
       sig { params(signature_class: T.class_of(DSPy::Signature), input_values: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
       def prepare_base_instrumentation_payload(signature_class, input_values)
+        # Validate LM is configured before accessing its properties
+        raise DSPy::ConfigurationError.missing_lm(self.class.name) if lm.nil?
+        
         {
           signature_class: signature_class.name,
           model: lm.model,

data/lib/dspy/prediction.rb

@@ -319,6 +319,9 @@ module DSPy
         end
         
         value.each do |k, v|
+          # Skip _type field from being added to the struct (it's not a real field)
+          next if k == :_type || k == "_type"
+          
           prop_info = struct_class.props[k]
           if prop_info
             prop_type = prop_info[:type_object] || prop_info[:type]
@@ -343,7 +346,27 @@ module DSPy
           value
         end
       when T::Types::Union
-        # For unions without discriminator, try each type
+        # Check if value has a _type field for automatic type detection
+        type_name = value[:_type] || value["_type"]
+        
+        if type_name
+          # Use _type field to determine which struct to instantiate
+          type.types.each do |t|
+            next if t == T::Utils.coerce(NilClass)
+            
+            if t.is_a?(T::Types::Simple) && t.raw_type < T::Struct
+              struct_name = t.raw_type.name.split('::').last
+              if struct_name == type_name
+                return convert_to_struct(value, t)
+              end
+            end
+          end
+          
+          # If no matching type found, raise an error
+          raise DSPy::DeserializationError, "Unknown type: #{type_name}. Expected one of: #{type.types.map { |t| t.is_a?(T::Types::Simple) && t.raw_type < T::Struct ? t.raw_type.name.split('::').last : nil }.compact.join(', ')}"
+        end
+        
+        # Fallback to trying each type if no _type field
         type.types.each do |t|
           next if t == T::Utils.coerce(NilClass)
           
@@ -398,7 +421,27 @@ module DSPy
 
     sig { params(hash: T::Hash[Symbol, T.untyped], union_type: T::Types::Union).returns(T.untyped) }
     def convert_hash_to_union_struct(hash, union_type)
-      # Try to match the hash structure to one of the union types
+      # First check if hash has a _type field for automatic type detection
+      type_name = hash[:_type] || hash["_type"]
+      
+      if type_name
+        # Use _type field to determine which struct to instantiate
+        union_type.types.each do |type|
+          next if type == T::Utils.coerce(NilClass)
+          
+          if type.is_a?(T::Types::Simple) && type.raw_type < T::Struct
+            struct_name = type.raw_type.name.split('::').last
+            if struct_name == type_name
+              return convert_to_struct(hash, type)
+            end
+          end
+        end
+        
+        # If no matching type found, raise an error
+        raise DSPy::DeserializationError, "Unknown type: #{type_name}. Expected one of: #{union_type.types.map { |t| t.is_a?(T::Types::Simple) && t.raw_type < T::Struct ? t.raw_type.name.split('::').last : nil }.compact.join(', ')}"
+      end
+      
+      # Fallback: Try to match the hash structure to one of the union types
       union_type.types.each do |type|
         next if type == T::Utils.coerce(NilClass)
         
@@ -412,6 +455,9 @@ module DSPy
               # Need to convert nested values too
               converted_hash = {}
               hash.each do |k, v|
+                # Skip _type field
+                next if k == :_type || k == "_type"
+                
                 prop_info = struct_class.props[k]
                 if prop_info
                   prop_type = prop_info[:type_object] || prop_info[:type]

data/lib/dspy/re_act.rb

@@ -256,7 +256,7 @@ module DSPy
       }) do
         # Generate thought and action
         thought_obj = @thought_generator.forward(
-          input_context: input_struct.serialize.to_json,
+          input_context: DSPy::TypeSerializer.serialize(input_struct).to_json,
           history: history,
           available_tools: available_tools_desc
         )
@@ -385,7 +385,7 @@ module DSPy
       return { should_finish: false } if observation.include?("Unknown action")
 
       observation_result = @observation_processor.forward(
-        input_context: input_struct.serialize.to_json,
+        input_context: DSPy::TypeSerializer.serialize(input_struct).to_json,
         history: history,
         observation: observation
       )
@@ -402,7 +402,7 @@ module DSPy
     sig { params(input_struct: T.untyped, history: T::Array[HistoryEntry], available_tools_desc: T::Array[T::Hash[String, T.untyped]], observation_result: T.untyped, iteration: Integer).returns(String) }
     def generate_forced_final_answer(input_struct, history, available_tools_desc, observation_result, iteration)
       final_thought = @thought_generator.forward(
-        input_context: input_struct.serialize.to_json,
+        input_context: DSPy::TypeSerializer.serialize(input_struct).to_json,
         history: history,
         available_tools: available_tools_desc
       )

data/lib/dspy/signature.rb

@@ -292,6 +292,19 @@ module DSPy
         properties = {}
         required = []
 
+        # Check if struct already has a _type field
+        if struct_class.props.key?(:_type)
+          raise DSPy::ValidationError, "_type field conflict: #{struct_class.name} already has a _type field defined. " \
+                                       "DSPy uses _type for automatic type detection in union types."
+        end
+
+        # Add automatic _type field for type detection
+        properties[:_type] = {
+          type: "string",
+          const: struct_class.name.split('::').last  # Use the simple class name
+        }
+        required << "_type"
+
         struct_class.props.each do |prop_name, prop_info|
           prop_type = prop_info[:type_object] || prop_info[:type]
           properties[prop_name] = type_to_json_schema(prop_type)

data/lib/dspy/type_serializer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module DSPy
+  class TypeSerializer
+    extend T::Sig
+
+    # Serialize a value, injecting _type fields for T::Struct instances
+    sig { params(value: T.untyped).returns(T.untyped) }
+    def self.serialize(value)
+      case value
+      when T::Struct
+        serialize_struct(value)
+      when Array
+        value.map { |item| serialize(item) }
+      when Hash
+        value.transform_values { |v| serialize(v) }
+      else
+        value
+      end
+    end
+
+    private
+
+    sig { params(struct: T::Struct).returns(T::Hash[String, T.untyped]) }
+    def self.serialize_struct(struct)
+      # Handle anonymous structs that don't have a name
+      class_name = struct.class.name
+      type_name = if class_name.nil? || class_name.empty?
+        # For anonymous structs, use a generic identifier
+        "AnonymousStruct"
+      else
+        class_name.split('::').last
+      end
+      
+      result = {
+        "_type" => type_name
+      }
+
+      # Get all props and serialize their values
+      struct.class.props.each do |prop_name, prop_info|
+        prop_value = struct.send(prop_name)
+        
+        # Skip nil values for optional fields
+        next if prop_value.nil? && prop_info[:fully_optional]
+        
+        # Recursively serialize nested values
+        result[prop_name.to_s] = serialize(prop_value)
+      end
+
+      result
+    end
+  end
+end

data/lib/dspy/version.rb

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

data/lib/dspy.rb

@@ -5,6 +5,8 @@ require 'dry/logger'
 require 'securerandom'
 
 require_relative 'dspy/version'
+require_relative 'dspy/errors'
+require_relative 'dspy/type_serializer'
 
 module DSPy
   extend Dry::Configurable
@@ -145,3 +147,20 @@ require_relative 'dspy/registry/signature_registry'
 require_relative 'dspy/registry/registry_manager'
 
 # 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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-07-20 00:00:00.000000000 Z
+date: 2025-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dry-configurable
@@ -162,6 +162,7 @@ files:
 - lib/dspy.rb
 - lib/dspy/chain_of_thought.rb
 - lib/dspy/code_act.rb
+- lib/dspy/errors.rb
 - lib/dspy/evaluate.rb
 - lib/dspy/example.rb
 - lib/dspy/few_shot_example.rb
@@ -222,6 +223,7 @@ files:
 - lib/dspy/tools/memory_toolset.rb
 - lib/dspy/tools/text_processing_toolset.rb
 - lib/dspy/tools/toolset.rb
+- lib/dspy/type_serializer.rb
 - lib/dspy/version.rb
 homepage: https://github.com/vicentereig/dspy.rb
 licenses: