dspy 0.2.0 → 0.3.1

data/lib/dspy/tools/{sorbet_tool.rb → base.rb}

@@ -6,70 +6,70 @@ require 'json'
 module DSPy
   module Tools
     # Base class for all Sorbet-based tools with DSL support
-    class SorbetTool
+    class Base
       extend T::Sig
       extend T::Helpers
-      
+
       class << self
         extend T::Sig
-        
+
         sig { returns(T.nilable(String)) }
         attr_reader :tool_name_value, :tool_description_value
-        
+
         # DSL method to set tool name
         sig { params(name: String).void }
         def tool_name(name)
           @tool_name_value = name
         end
-        
+
         # DSL method to set tool description
         sig { params(description: String).void }
         def tool_description(description)
           @tool_description_value = description
         end
-        
+
         # Get the JSON schema for the call method based on its Sorbet signature
         sig { returns(T::Hash[Symbol, T.untyped]) }
         def call_schema
           method_obj = instance_method(:call)
           sig_info = T::Utils.signature_for_method(method_obj)
-          
+
           if sig_info.nil?
             # Fallback for methods without signatures
-            return { 
-              type: :object, 
-              properties: {}, 
-              required: [] 
+            return {
+              type: :object,
+              properties: {},
+              required: []
             }
           end
-          
+
           properties = {}
           required = []
-          
+
           # Handle positional arguments
           sig_info.arg_types.each do |param_name, param_type|
             next if param_name == :block # Skip block parameters
-            
+
             properties[param_name] = {
               type: sorbet_type_to_json_schema(param_type)[:type],
               description: "Parameter #{param_name}"
             }
-            
+
             # Check if parameter is required (not nilable)
             unless param_type.class.name.include?('Union') && param_type.name.include?('NilClass')
               required << param_name.to_s
             end
           end
-          
+
           # Handle keyword arguments (more common in Ruby)
           sig_info.kwarg_types.each do |param_name, param_type|
             next if param_name == :block # Skip block parameters
-            
+
             properties[param_name] = {
               type: sorbet_type_to_json_schema(param_type)[:type],
               description: "Parameter #{param_name}"
             }
-            
+
             # Check if parameter is required by looking at required kwarg names
             if sig_info.req_kwarg_names.include?(param_name)
               required << param_name.to_s
@@ -77,22 +77,22 @@ module DSPy
               properties[param_name][:description] += " (optional)"
             end
           end
-          
+
           {
             type: :object,
             properties: properties,
             required: required
           }
         end
-        
+
         private
-        
+
         # Convert Sorbet types to JSON Schema types
         sig { params(sorbet_type: T.untyped).returns(T::Hash[Symbol, T.untyped]) }
         def sorbet_type_to_json_schema(sorbet_type)
           if sorbet_type.is_a?(T::Types::Simple)
             raw_type = sorbet_type.raw_type
-            
+
             if raw_type == String
               { type: :string }
             elsif raw_type == Integer
@@ -128,18 +128,18 @@ module DSPy
           end
         end
       end
-      
+
       # Instance methods that tools can use
       sig { returns(String) }
       def name
         self.class.tool_name_value || self.class.name&.split('::')&.last&.downcase || 'unknown_tool'
       end
-      
+
       sig { returns(String) }
       def description
         self.class.tool_description_value || "Tool: #{name}"
       end
-      
+
       # Get the JSON schema string for the tool, formatted for LLM consumption
       sig { returns(String) }
       def schema
@@ -149,15 +149,15 @@ module DSPy
           description: description,
           parameters: schema_obj
         }
-        JSON.pretty_generate(tool_info)
+        JSON.generate(tool_info)
       end
-      
+
       # Dynamic call method for ReAct agent - parses JSON arguments and calls the typed method
       sig { params(args_json: T.untyped).returns(T.untyped) }
       def dynamic_call(args_json)
         # Parse arguments based on the call schema
         schema = self.class.call_schema
-        
+
         if schema[:properties].empty?
           # No parameters - call without arguments
           call
@@ -175,7 +175,7 @@ module DSPy
                 else
                   return "Error: Expected Hash or JSON string"
                 end
-          
+
           # Convert string keys to symbols and validate types
           kwargs = {}
           schema[:properties].each do |param_name, param_schema|
@@ -186,17 +186,17 @@ module DSPy
               return "Error: Missing required parameter: #{key}"
             end
           end
-          
+
           call(**kwargs)
         end
       rescue => e
         "Error: #{e.message}"
       end
-      
+
       # Subclasses must implement their own call method with their own signature
-      
+
       private
-      
+
       # Convert argument to the expected type based on JSON schema
       sig { params(value: T.untyped, schema: T::Hash[Symbol, T.untyped]).returns(T.untyped) }
       def convert_argument_type(value, schema)

data/lib/dspy/tools.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'tools/sorbet_tool'
+require_relative 'tools/base'
 
 module DSPy
   # Define the tools available to the agent

data/lib/dspy.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
-require 'ruby_llm'
-require 'dry-schema'
+require 'sorbet-runtime'
 require 'dry-configurable'
 require 'dry/logger'
-require_relative 'dspy/ext/dry_schema'
 
 module DSPy
   extend Dry::Configurable
@@ -15,7 +13,6 @@ module DSPy
   end
 end
 
-require_relative 'dspy/types'
 require_relative 'dspy/module'
 require_relative 'dspy/field'
 require_relative 'dspy/signature'
@@ -23,10 +20,8 @@ require_relative 'dspy/lm'
 require_relative 'dspy/predict'
 require_relative 'dspy/chain_of_thought'
 require_relative 'dspy/re_act'
+require_relative 'dspy/subscribers/logger_subscriber'
 require_relative 'dspy/tools'
+require_relative 'dspy/instrumentation'
 
-# Sorbet implementation
-require_relative 'dspy/sorbet_signature'
-require_relative 'dspy/sorbet_module'
-require_relative 'dspy/sorbet_predict'
-require_relative 'dspy/sorbet_chain_of_thought'
+# LoggerSubscriber will be lazy-initialized when first accessed

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: dspy
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Vicente Reig Rincón de Arellano
 bindir: bin
 cert_chain: []
-date: 2025-06-01 00:00:00.000000000 Z
+date: 2025-06-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: ruby_llm
+  name: dry-configurable
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -24,21 +24,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: dry-schema
+  name: dry-logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.14'
+        version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: dry-configurable
+  name: dry-monitor
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -52,61 +52,89 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.0'
 - !ruby/object:Gem::Dependency
-  name: dry-logger
+  name: async
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.23'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.23'
 - !ruby/object:Gem::Dependency
-  name: ruby-openai
+  name: openai
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: 0.9.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '8.0'
+        version: 0.9.0
 - !ruby/object:Gem::Dependency
-  name: async
+  name: anthropic
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.23'
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.23'
+        version: 1.1.0
 - !ruby/object:Gem::Dependency
-  name: openai
+  name: ruby_llm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: sorbet-schema
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0.pre.alpha.4
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0.pre.alpha.4
+        version: '0.3'
 description: A Ruby implementation of DSPy, a framework for programming with large
   language models
 email:
@@ -118,21 +146,25 @@ files:
 - README.md
 - lib/dspy.rb
 - lib/dspy/chain_of_thought.rb
-- lib/dspy/ext/dry_schema.rb
 - lib/dspy/field.rb
+- lib/dspy/instrumentation.rb
+- lib/dspy/instrumentation/token_tracker.rb
 - lib/dspy/lm.rb
+- lib/dspy/lm/adapter.rb
+- lib/dspy/lm/adapter_factory.rb
+- lib/dspy/lm/adapters/anthropic_adapter.rb
+- lib/dspy/lm/adapters/openai_adapter.rb
+- lib/dspy/lm/adapters/ruby_llm_adapter.rb
+- lib/dspy/lm/errors.rb
+- lib/dspy/lm/response.rb
 - lib/dspy/module.rb
 - lib/dspy/predict.rb
 - lib/dspy/re_act.rb
+- lib/dspy/schema_adapters.rb
 - lib/dspy/signature.rb
-- lib/dspy/sorbet_chain_of_thought.rb
-- lib/dspy/sorbet_module.rb
-- lib/dspy/sorbet_predict.rb
-- lib/dspy/sorbet_re_act.rb
-- lib/dspy/sorbet_signature.rb
+- lib/dspy/subscribers/logger_subscriber.rb
 - lib/dspy/tools.rb
-- lib/dspy/tools/sorbet_tool.rb
-- lib/dspy/types.rb
+- lib/dspy/tools/base.rb
 homepage: https://github.com/vicentereig/dspy.rb
 licenses:
 - MIT
@@ -144,7 +176,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/dspy/ext/dry_schema.rb

@@ -1,94 +0,0 @@
-require 'dry/schema/version'
-
-if Dry::Schema::VERSION > Gem::Version.new('1.15')
-  raise 'Double check this monkey path before upgrading drys-schema.'
-end
-
-Dry::Schema.load_extensions(:json_schema)
-# Monkey patch Macros::Core to add meta method
-module Dry
-  module Schema
-    module Macros
-      class Core
-        def meta(metadata)
-          schema_dsl.meta(name, metadata)
-          self
-        end
-      end
-    end
-  end
-end
-
-# Monkey patch DSL to store metadata
-module Dry
-  module Schema
-    class DSL
-      def meta(name, metadata)
-        @metas ||= {}
-        @metas[name] = metadata
-        self
-      end
-
-      def metas
-        @metas ||= {}
-      end
-
-      # Ensure metas are included in new instances
-      alias_method :original_new, :new
-      def new(**options, &block)
-        options[:metas] = metas
-        original_new(**options, &block)
-      end
-
-      # Ensure processor has access to metas
-      alias_method :original_call, :call
-      def call
-        processor = original_call
-        processor.instance_variable_set(:@schema_metas, metas)
-        processor
-      end
-    end
-  end
-end
-
-# Monkey patch Processor to expose schema_metas
-module Dry
-  module Schema
-    class Processor
-      attr_reader :schema_metas
-
-      # Add schema_metas accessor
-      def schema_metas
-        @schema_metas ||= {}
-      end
-    end
-  end
-end
-
-# Directly monkey patch the JSON Schema generation
-module Dry
-  module Schema
-    module JSONSchema
-      module SchemaMethods
-        # Override the original json_schema method
-        def json_schema(loose: false)
-          compiler = SchemaCompiler.new(root: true, loose: loose)
-          compiler.call(to_ast)
-          result = compiler.to_hash
-
-          # Add descriptions to properties from schema_metas
-          if respond_to?(:schema_metas) && !schema_metas.empty?
-            schema_metas.each do |key, meta|
-              if meta[:description] && result[:properties][key]
-                result[:properties][key][:description] = meta[:description]
-              end
-            end
-          end
-
-          result
-        end
-      end
-    end
-  end
-end
-

data/lib/dspy/sorbet_chain_of_thought.rb

@@ -1,91 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require 'sorbet-runtime'
-require_relative 'sorbet_predict'
-require_relative 'sorbet_signature'
-
-module DSPy
-  # Enhances prediction by encouraging step-by-step reasoning
-  # before providing a final answer using Sorbet signatures.
-  class SorbetChainOfThought < SorbetPredict
-    extend T::Sig
-    
-    FieldDescriptor = DSPy::SorbetSignature::FieldDescriptor
-    
-    sig { params(signature_class: T.class_of(DSPy::SorbetSignature)).void }
-    def initialize(signature_class)
-      @original_signature = signature_class
-      
-      # Create enhanced output struct with reasoning
-      enhanced_output_struct = create_enhanced_output_struct(signature_class)
-      
-      # Create enhanced signature class
-      enhanced_signature = Class.new(DSPy::SorbetSignature) do
-        # Set the description
-        description "#{signature_class.description} Think step by step."
-        
-        # Use the same input struct and copy field descriptors
-        @input_struct_class = signature_class.input_struct_class
-        @input_field_descriptors = signature_class.instance_variable_get(:@input_field_descriptors) || {}
-        
-        # Use the enhanced output struct and create field descriptors for it
-        @output_struct_class = enhanced_output_struct
-        
-        # Create field descriptors for the enhanced output struct
-        @output_field_descriptors = {}
-        
-        # Copy original output field descriptors
-        original_output_descriptors = signature_class.instance_variable_get(:@output_field_descriptors) || {}
-        @output_field_descriptors.merge!(original_output_descriptors)
-        
-        # Add reasoning field descriptor
-        @output_field_descriptors[:reasoning] = FieldDescriptor.new(String, nil)
-        
-        class << self
-          attr_reader :input_struct_class, :output_struct_class
-        end
-      end
-      
-      # Call parent constructor with enhanced signature
-      super(enhanced_signature)
-    end
-    
-    private
-    
-    sig { params(signature_class: T.class_of(DSPy::SorbetSignature)).returns(T.class_of(T::Struct)) }
-    def create_enhanced_output_struct(signature_class)
-      # Get original output props
-      original_props = signature_class.output_struct_class.props
-      
-      # Create new struct class with reasoning added
-      Class.new(T::Struct) do
-        # Add all original fields
-        original_props.each do |name, prop|
-          # Extract the type and other options
-          type = prop[:type]
-          options = prop.except(:type, :type_object, :accessor_key, :sensitivity, :redaction)
-          
-          # Handle default values
-          if options[:default]
-            const name, type, default: options[:default]
-          elsif options[:factory]
-            const name, type, factory: options[:factory]
-          else
-            const name, type
-          end
-        end
-        
-        # Add reasoning field
-        const :reasoning, String
-      end
-    end
-    
-    sig { override.returns(T::Hash[Symbol, T.untyped]) }
-    def generate_example_output
-      example = super
-      example[:reasoning] = "Let me think through this step by step..."
-      example
-    end
-  end
-end

data/lib/dspy/sorbet_module.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'sorbet-runtime'
-
-module DSPy
-  class SorbetModule
-    extend T::Sig
-    extend T::Generic
-
-    # The main forward method that users will call is generic and type parameterized
-    sig do
-      type_parameters(:I, :O)
-        .params(
-          input_values: T.type_parameter(:I)
-        )
-        .returns(T.type_parameter(:O))
-    end
-    def forward(**input_values)
-      # Cast the result of forward_untyped to the expected output type
-      T.cast(forward_untyped(**input_values), T.type_parameter(:O))
-    end
-
-    # The implementation method that subclasses must override
-    sig { params(input_values: T.untyped).returns(T.untyped) }
-    def forward_untyped(**input_values)
-      raise NotImplementedError, "Subclasses must implement forward_untyped method"
-    end
-
-    # The main call method that users will call is generic and type parameterized
-    sig do
-      type_parameters(:I, :O)
-        .params(
-          input_values: T.type_parameter(:I)
-        )
-        .returns(T.type_parameter(:O))
-    end
-    def call(**input_values)
-      forward(**input_values)
-    end
-
-    # The implementation method for call
-    sig { params(input_values: T.untyped).returns(T.untyped) }
-    def call_untyped(**input_values)
-      forward_untyped(**input_values)
-    end
-  end
-end