dspy 0.34.2 → 0.34.4

data/lib/dspy/storage/program_storage.rb

@@ -198,7 +198,7 @@ module DSPy
           emit_save_complete_event(saved_program)
           saved_program
           
-        rescue => error
+        rescue StandardError => error
           emit_save_error_event(program_id, error)
           raise
         end
@@ -223,7 +223,7 @@ module DSPy
           emit_load_complete_event(saved_program)
           saved_program
           
-        rescue => error
+        rescue StandardError => error
           emit_load_error_event(program_id, error)
           nil
         end

data/lib/dspy/structured_outputs_prompt.rb

@@ -16,12 +16,12 @@ module DSPy
         output_schema: T::Hash[Symbol, T.untyped],
         few_shot_examples: T::Array[T.untyped],
         signature_class_name: T.nilable(String),
-        schema_format: Symbol,
+        schema_format: T.nilable(Symbol),
         signature_class: T.nilable(T.class_of(Signature)),
-        data_format: Symbol
+        data_format: T.nilable(Symbol)
       ).void
     end
-    def initialize(instruction:, input_schema:, output_schema:, few_shot_examples: [], signature_class_name: nil, schema_format: :json, signature_class: nil, data_format: :json)
+    def initialize(instruction:, input_schema:, output_schema:, few_shot_examples: [], signature_class_name: nil, schema_format: nil, signature_class: nil, data_format: nil)
       normalized_examples = few_shot_examples.map do |example|
         case example
         when FewShotExample
@@ -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/teleprompt/utils.rb

@@ -360,7 +360,7 @@ module DSPy
               )
               successful_demos << demo
             end
-          rescue => e
+          rescue StandardError => e
             # Continue on errors
             DSPy.logger.warn("Bootstrap error: #{e.message}") if DSPy.logger
           end
@@ -513,7 +513,7 @@ module DSPy
               emit_bootstrap_example_event(index, false, "Prediction did not match expected output")
             end
 
-          rescue => error
+          rescue StandardError => error
             error_count += 1
             failed << example
             emit_bootstrap_example_event(index, false, error.message)

data/lib/dspy/tools/github_cli_toolset.rb

@@ -105,7 +105,7 @@ module DSPy
         else
           "Failed to list issues: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error listing issues: #{e.message}"
       end
 
@@ -140,7 +140,7 @@ module DSPy
         else
           "Failed to list pull requests: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error listing pull requests: #{e.message}"
       end
 
@@ -159,7 +159,7 @@ module DSPy
         else
           "Failed to get issue: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error getting issue: #{e.message}"
       end
 
@@ -178,7 +178,7 @@ module DSPy
         else
           "Failed to get pull request: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error getting pull request: #{e.message}"
       end
 
@@ -214,7 +214,7 @@ module DSPy
         else
           "API request failed: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error making API request: #{e.message}"
       end
 
@@ -231,7 +231,7 @@ module DSPy
         else
           "Failed to fetch traffic views: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error fetching traffic views: #{e.message}"
       end
 
@@ -248,7 +248,7 @@ module DSPy
         else
           "Failed to fetch traffic clones: #{result[:error]}"
         end
-      rescue => e
+      rescue StandardError => e
         "Error fetching traffic clones: #{e.message}"
       end
 

data/lib/dspy/tools/text_processing_toolset.rb

@@ -52,7 +52,7 @@ module DSPy
         else
           result
         end
-      rescue => e
+      rescue StandardError => e
         "Error running grep: #{e.message}"
       end
 
@@ -92,7 +92,7 @@ module DSPy
         else
           result
         end
-      rescue => e
+      rescue StandardError => e
         "Error running ripgrep: #{e.message}"
       end
 

data/lib/dspy/tools/toolset.rb

@@ -187,7 +187,7 @@ module DSPy
 
             @instance.send(@method_name, **kwargs)
           end
-        rescue => e
+        rescue StandardError => e
           "Error: #{e.message}"
         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.2"
+  VERSION = "0.34.4"
 end

data/lib/dspy.rb

@@ -141,7 +141,7 @@ module DSPy
       # Events are instant moments in time, not ongoing operations
       span = DSPy::Observability.start_span(event_name, flattened_attributes)
       DSPy::Observability.finish_span(span) if span
-    rescue => e
+    rescue StandardError => e
       # Log error but don't let it break the event system
       # Use emit_log directly to avoid infinite recursion
       emit_log('event.span_creation_error', {
@@ -159,13 +159,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
@@ -221,8 +269,6 @@ require_relative 'dspy/lm'
 require_relative 'dspy/image'
 require_relative 'dspy/prediction'
 require_relative 'dspy/predict'
-require_relative 'dspy/events/subscribers'
-require_relative 'dspy/events/subscriber_mixin'
 require_relative 'dspy/chain_of_thought'
 require_relative 'dspy/re_act'
 require_relative 'dspy/evals'
@@ -248,7 +294,6 @@ begin
 rescue LoadError
 end
 require_relative 'dspy/tools'
-require_relative 'dspy/memory'
 
 begin
   require 'dspy/datasets'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.34.2
+  version: 0.34.4
 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
@@ -135,20 +141,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.0
-- !ruby/object:Gem::Dependency
-  name: informers
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.2'
 description: The Ruby framework for programming with large language models. DSPy.rb
   brings structured LLM programming to Ruby developers. Instead of wrestling with
   prompt strings and parsing responses, you define typed signatures using idiomatic
@@ -170,8 +162,6 @@ files:
 - lib/dspy/evals.rb
 - lib/dspy/evals/version.rb
 - lib/dspy/events.rb
-- lib/dspy/events/subscriber_mixin.rb
-- lib/dspy/events/subscribers.rb
 - lib/dspy/events/types.rb
 - lib/dspy/example.rb
 - lib/dspy/ext/struct_descriptions.rb
@@ -189,14 +179,6 @@ files:
 - lib/dspy/lm/response.rb
 - lib/dspy/lm/usage.rb
 - lib/dspy/lm/vision_models.rb
-- lib/dspy/memory.rb
-- lib/dspy/memory/embedding_engine.rb
-- lib/dspy/memory/in_memory_store.rb
-- lib/dspy/memory/local_embedding_engine.rb
-- lib/dspy/memory/memory_compactor.rb
-- lib/dspy/memory/memory_manager.rb
-- lib/dspy/memory/memory_record.rb
-- lib/dspy/memory/memory_store.rb
 - lib/dspy/mixins/instruction_updatable.rb
 - lib/dspy/mixins/struct_builder.rb
 - lib/dspy/mixins/type_coercion.rb
@@ -238,7 +220,6 @@ files:
 - lib/dspy/tools.rb
 - lib/dspy/tools/base.rb
 - lib/dspy/tools/github_cli_toolset.rb
-- lib/dspy/tools/memory_toolset.rb
 - lib/dspy/tools/schema.rb
 - lib/dspy/tools/text_processing_toolset.rb
 - lib/dspy/tools/toolset.rb

data/lib/dspy/events/subscriber_mixin.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'sorbet-runtime'
-
-module DSPy
-  module Events
-    # Mixin for adding class-level event subscriptions
-    # Provides a clean way to subscribe to events at the class level
-    # instead of requiring instance-based subscriptions
-    #
-    # Usage:
-    #   class MyTracker
-    #     include DSPy::Events::SubscriberMixin
-    #     
-    #     add_subscription('llm.*') do |name, attrs|
-    #       # Handle LLM events globally for this class
-    #     end
-    #   end
-    module SubscriberMixin
-      extend T::Sig
-
-      def self.included(base)
-        base.extend(ClassMethods)
-        base.class_eval do
-          @event_subscriptions = []
-          @subscription_mutex = Mutex.new
-          
-          # Initialize subscriptions when the class is first loaded
-          @subscriptions_initialized = false
-        end
-      end
-
-      module ClassMethods
-        extend T::Sig
-
-        # Add a class-level event subscription
-        sig { params(pattern: String, block: T.proc.params(arg0: String, arg1: T::Hash[T.any(String, Symbol), T.untyped]).void).returns(String) }
-        def add_subscription(pattern, &block)
-          subscription_mutex.synchronize do
-            subscription_id = DSPy.events.subscribe(pattern, &block)
-            event_subscriptions << subscription_id
-            subscription_id
-          end
-        end
-
-        # Remove all subscriptions for this class
-        sig { void }
-        def unsubscribe_all
-          subscription_mutex.synchronize do
-            event_subscriptions.each { |id| DSPy.events.unsubscribe(id) }
-            event_subscriptions.clear
-          end
-        end
-
-        # Get list of active subscription IDs
-        sig { returns(T::Array[String]) }
-        def subscriptions
-          subscription_mutex.synchronize do
-            event_subscriptions.dup
-          end
-        end
-
-        private
-
-        # Thread-safe access to subscriptions array
-        sig { returns(T::Array[String]) }
-        def event_subscriptions
-          @event_subscriptions ||= []
-        end
-
-        # Thread-safe access to mutex
-        sig { returns(Mutex) }
-        def subscription_mutex
-          @subscription_mutex ||= Mutex.new
-        end
-      end
-    end
-  end
-end

data/lib/dspy/events/subscribers.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module DSPy
-  module Events
-    # Base subscriber class for event-driven patterns
-    # This provides the foundation for creating custom event subscribers
-    # 
-    # Example usage:
-    #   class MySubscriber < DSPy::Events::BaseSubscriber
-    #     def subscribe
-    #       add_subscription('llm.*') do |event_name, attributes|
-    #         # Handle LLM events
-    #       end
-    #     end
-    #   end
-    #
-    #   subscriber = MySubscriber.new
-    #   # subscriber will start receiving events
-    #   subscriber.unsubscribe # Clean up when done
-    class BaseSubscriber
-      def initialize
-        @subscriptions = []
-      end
-      
-      def subscribe
-        raise NotImplementedError, "Subclasses must implement #subscribe"
-      end
-      
-      def unsubscribe
-        @subscriptions.each { |id| DSPy.events.unsubscribe(id) }
-        @subscriptions.clear
-      end
-      
-      protected
-      
-      def add_subscription(pattern, &block)
-        subscription_id = DSPy.events.subscribe(pattern, &block)
-        @subscriptions << subscription_id
-        subscription_id
-      end
-    end
-  end
-end

data/lib/dspy/memory/embedding_engine.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'sorbet-runtime'
-
-module DSPy
-  module Memory
-    # Abstract base class for embedding engines
-    class EmbeddingEngine
-      extend T::Sig
-      extend T::Helpers
-      abstract!
-
-      # Generate embeddings for a single text
-      sig { abstract.params(text: String).returns(T::Array[Float]) }
-      def embed(text); end
-
-      # Generate embeddings for multiple texts (batch processing)
-      sig { abstract.params(texts: T::Array[String]).returns(T::Array[T::Array[Float]]) }
-      def embed_batch(texts); end
-
-      # Get the dimension of embeddings produced by this engine
-      sig { abstract.returns(Integer) }
-      def embedding_dimension; end
-
-      # Get the model name/identifier
-      sig { abstract.returns(String) }
-      def model_name; end
-
-      # Check if the engine is ready to use
-      sig { returns(T::Boolean) }
-      def ready?
-        true
-      end
-
-      # Get engine statistics
-      sig { returns(T::Hash[Symbol, T.untyped]) }
-      def stats
-        {
-          model_name: model_name,
-          embedding_dimension: embedding_dimension,
-          ready: ready?
-        }
-      end
-
-      # Normalize a vector to unit length
-      sig { params(vector: T::Array[Float]).returns(T::Array[Float]) }
-      def normalize_vector(vector)
-        magnitude = Math.sqrt(vector.sum { |x| x * x })
-        return vector if magnitude == 0.0
-        vector.map { |x| x / magnitude }
-      end
-
-      # Calculate cosine similarity between two vectors
-      sig { params(a: T::Array[Float], b: T::Array[Float]).returns(Float) }
-      def cosine_similarity(a, b)
-        return 0.0 if a.empty? || b.empty? || a.size != b.size
-        
-        dot_product = a.zip(b).sum { |x, y| x * y }
-        magnitude_a = Math.sqrt(a.sum { |x| x * x })
-        magnitude_b = Math.sqrt(b.sum { |x| x * x })
-        
-        return 0.0 if magnitude_a == 0.0 || magnitude_b == 0.0
-        
-        dot_product / (magnitude_a * magnitude_b)
-      end
-    end
-  end
-end