dspy 0.2.0 → 0.3.0

data/lib/dspy/lm.rb

@@ -1,43 +1,108 @@
 # frozen_string_literal: true
-require 'ruby_llm'
+
+# Load adapter infrastructure
+require_relative 'lm/errors'
+require_relative 'lm/response'
+require_relative 'lm/adapter'
+require_relative 'lm/adapter_factory'
+
+# Load instrumentation
+require_relative 'instrumentation'
+require_relative 'instrumentation/token_tracker'
+
+# Load adapters
+require_relative 'lm/adapters/openai_adapter'
+require_relative 'lm/adapters/anthropic_adapter'
+require_relative 'lm/adapters/ruby_llm_adapter'
 
 module DSPy
   class LM
-    attr_reader :model_id, :api_key, :model, :provider
+    attr_reader :model_id, :api_key, :model, :provider, :adapter
 
     def initialize(model_id, api_key: nil)
       @model_id = model_id
       @api_key = api_key
-      # Configure RubyLLM with the API key if provided
-      if model_id.start_with?('openai/')
-        RubyLLM.configure do |config|
-          config.openai_api_key = api_key
-        end
-        @provider = :openai
-        @model = model_id.split('/').last
-      elsif model_id.start_with?('anthropic/')
-        RubyLLM.configure do |config|
-          config.anthropic_api_key = api_key
-        end
-        @provider = :anthropic
-        @model = model_id.split('/').last
-      else
-        raise ArgumentError, "Unsupported model provider: #{model_id}"
-      end
+      
+      # Parse provider and model from model_id
+      @provider, @model = parse_model_id(model_id)
+      
+      # Create appropriate adapter
+      @adapter = AdapterFactory.create(model_id, api_key: api_key)
     end
 
     def chat(inference_module, input_values, &block)
       signature_class = inference_module.signature_class
-      chat = RubyLLM.chat(model: model)
+      
+      # Build messages from inference module
+      messages = build_messages(inference_module, input_values)
+      
+      # Calculate input size for monitoring
+      input_text = messages.map { |m| m[:content] }.join(' ')
+      input_size = input_text.length
+      
+      # Instrument LM request
+      response = Instrumentation.instrument('dspy.lm.request', {
+        gen_ai_operation_name: 'chat',
+        gen_ai_system: provider,
+        gen_ai_request_model: model,
+        signature_class: signature_class.name,
+        provider: provider,
+        adapter_class: adapter.class.name,
+        input_size: input_size
+      }) do
+        adapter.chat(messages: messages, &block)
+      end
+      
+      # Extract actual token usage from response (more accurate than estimation)
+      token_usage = Instrumentation::TokenTracker.extract_token_usage(response, provider)
+      
+      # Emit token usage event if available
+      if token_usage.any?
+        Instrumentation.emit('dspy.lm.tokens', token_usage.merge({
+          gen_ai_system: provider,
+          gen_ai_request_model: model,
+          signature_class: signature_class.name
+        }))
+      end
+      
+      # Instrument response parsing
+      parsed_result = Instrumentation.instrument('dspy.lm.response.parsed', {
+        signature_class: signature_class.name,
+        provider: provider,
+        response_length: response.content&.length || 0
+      }) do
+        parse_response(response, input_values, signature_class)
+      end
+      
+      parsed_result
+    end
+
+    private
+
+    def parse_model_id(model_id)
+      if model_id.include?('/')
+        provider, model = model_id.split('/', 2)
+        [provider, model]
+      else
+        # Legacy format: assume ruby_llm for backward compatibility
+        ['ruby_llm', model_id]
+      end
+    end
+
+    def build_messages(inference_module, input_values)
+      messages = []
+      
+      # Add system message
       system_prompt = inference_module.system_signature
+      messages << { role: 'system', content: system_prompt } if system_prompt
+      
+      # Add user message
       user_prompt = inference_module.user_signature(input_values)
-      chat.add_message role: :system, content: system_prompt
-      chat.ask(user_prompt, &block)
-
-      parse_response(chat.messages.last, input_values, signature_class)
+      messages << { role: 'user', content: user_prompt }
+      
+      messages
     end
 
-    private
     def parse_response(response, input_values, signature_class)
       # Try to parse the response as JSON
       content = response.content
@@ -52,22 +117,9 @@ module DSPy
       begin
         json_payload = JSON.parse(content)
 
-        # Handle different signature types
-        if signature_class < DSPy::SorbetSignature
-          # For Sorbet signatures, just return the parsed JSON
-          # The SorbetPredict will handle validation
-          json_payload
-        else
-          # Original dry-schema based handling
-          output = signature_class.output_schema.call(json_payload)
-
-          result_schema = Dry::Schema.JSON(parent: [signature_class.input_schema, signature_class.output_schema])
-          result = output.to_h.merge(input_values)
-          # create an instance with input and output schema
-          poro_result = result_schema.call(result)
-
-          poro_result.to_h
-        end
+        # For Sorbet signatures, just return the parsed JSON
+        # The Predict will handle validation
+        json_payload
       rescue JSON::ParserError
         raise "Failed to parse LLM response as JSON: #{content}"
       end

data/lib/dspy/module.rb

@@ -1,13 +1,58 @@
 # frozen_string_literal: true
 
+require 'sorbet-runtime'
+require 'dry-configurable'
+
 module DSPy
   class Module
-    def forward(...)
-      raise NotImplementedError, "Subclasses must implement forward method"
+    extend T::Sig
+    extend T::Generic
+    include Dry::Configurable
+
+    # Per-instance LM configuration
+    setting :lm, default: nil
+
+    # 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
-    
-    def call(...)
-      forward(...)
+
+    # 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
+
+    # Get the configured LM for this instance, falling back to global
+    sig { returns(T.untyped) }
+    def lm
+      config.lm || DSPy.config.lm
     end
   end
-end 
+end

data/lib/dspy/predict.rb

@@ -1,35 +1,53 @@
 # frozen_string_literal: true
 
+require 'sorbet-runtime'
+require_relative 'module'
+require_relative 'instrumentation'
+
 module DSPy
-  class PredictionInvalidError < RuntimeError
-    attr_accessor :errors
+  # Exception raised when prediction fails validation
+  class PredictionInvalidError < StandardError
+    extend T::Sig
+
+    sig { params(errors: T::Hash[T.untyped, T.untyped]).void }
     def initialize(errors)
       @errors = errors
-      super("Prediction invalid: #{errors.to_h}")
+      super("Prediction validation failed: #{errors}")
     end
+
+    sig { returns(T::Hash[T.untyped, T.untyped]) }
+    attr_reader :errors
   end
+
   class Predict < DSPy::Module
+    extend T::Sig
+
+    sig { returns(T.class_of(Signature)) }
     attr_reader :signature_class
 
+    sig { params(signature_class: T.class_of(Signature)).void }
     def initialize(signature_class)
+      super()
       @signature_class = signature_class
     end
 
+    sig { returns(String) }
     def system_signature
       <<-PROMPT
       Your input schema fields are:
         ```json
-         #{JSON.generate(@signature_class.input_schema.json_schema)}
+         #{JSON.generate(@signature_class.input_json_schema)}
         ```
       Your output schema fields are:
         ```json
-          #{JSON.generate(@signature_class.output_schema.json_schema)}
+          #{JSON.generate(@signature_class.output_json_schema)}
         ````
+      
       All interactions will be structured in the following way, with the appropriate values filled in.
 
       ## Input values
         ```json
-          {input_values}
+         {input_values}
         ```  
       ## Output values
       Respond exclusively with the output schema fields in the json block below.
@@ -42,6 +60,7 @@ module DSPy
       PROMPT
     end
 
+    sig { params(input_values: T::Hash[Symbol, T.untyped]).returns(String) }
     def user_signature(input_values)
       <<-PROMPT
         ## Input Values
@@ -54,19 +73,120 @@ module DSPy
       PROMPT
     end
 
-    def lm
-      DSPy.config.lm
+    sig { override.params(kwargs: T.untyped).returns(T.type_parameter(:O)) }
+    def forward(**kwargs)
+      @last_input_values = kwargs.clone
+      T.cast(forward_untyped(**kwargs), T.type_parameter(:O))
     end
 
-    def forward(**input_values)
-      DSPy.logger.info( module: self.class.to_s, **input_values)
-      result = @signature_class.input_schema.call(input_values)
-      if result.success?
+    sig { params(input_values: T.untyped).returns(T.untyped) }
+    def forward_untyped(**input_values)
+      # Prepare instrumentation payload
+      input_fields = input_values.keys.map(&:to_s)
+      
+      Instrumentation.instrument('dspy.predict', {
+        signature_class: @signature_class.name,
+        model: lm.model,
+        provider: lm.provider,
+        input_fields: input_fields
+      }) do
+        # Validate input
+        begin
+          _input_struct = @signature_class.input_struct_class.new(**input_values)
+        rescue ArgumentError => e
+          # Emit validation error event
+          Instrumentation.emit('dspy.predict.validation_error', {
+            signature_class: @signature_class.name,
+            validation_type: 'input',
+            validation_errors: { input: e.message }
+          })
+          raise PredictionInvalidError.new({ input: e.message })
+        end
+
+        # Call LM
         output_attributes = lm.chat(self, input_values)
-        poro_class = Data.define(*output_attributes.keys)
-        return poro_class.new(*output_attributes.values)
+
+        output_attributes = output_attributes.transform_keys(&:to_sym)
+
+        output_props = @signature_class.output_struct_class.props
+        output_attributes = output_attributes.map do |key, value|
+          prop_type = output_props[key][:type] if output_props[key]
+          if prop_type
+            # Check if it's an enum (can be raw Class or T::Types::Simple)
+            enum_class = if prop_type.is_a?(Class) && prop_type < T::Enum
+                           prop_type
+                         elsif prop_type.is_a?(T::Types::Simple) && prop_type.raw_type < T::Enum
+                           prop_type.raw_type
+                         end
+
+            if enum_class
+              [key, enum_class.deserialize(value)]
+            elsif prop_type == Float || (prop_type.is_a?(T::Types::Simple) && prop_type.raw_type == Float)
+              [key, value.to_f]
+            elsif prop_type == Integer || (prop_type.is_a?(T::Types::Simple) && prop_type.raw_type == Integer)
+              [key, value.to_i]
+            else
+              [key, value]
+            end
+          else
+            [key, value]
+          end
+        end.to_h
+
+        # Create combined struct with both input and output values
+        begin
+          combined_struct = create_combined_struct_class
+          all_attributes = input_values.merge(output_attributes)
+          combined_struct.new(**all_attributes)
+        rescue ArgumentError => e
+          raise PredictionInvalidError.new({ output: e.message })
+        rescue TypeError => e
+          raise PredictionInvalidError.new({ output: e.message })
+        end
+      end
+    end
+
+    private
+
+    sig { returns(T.class_of(T::Struct)) }
+    def create_combined_struct_class
+      input_props = @signature_class.input_struct_class.props
+      output_props = @signature_class.output_struct_class.props
+      
+      # Create a new struct class that combines input and output fields
+      Class.new(T::Struct) do
+        extend T::Sig
+        
+        # Add input fields
+        input_props.each do |name, prop_info|
+          if prop_info[:rules]&.any? { |rule| rule.is_a?(T::Props::NilableRules) }
+            prop name, prop_info[:type], default: prop_info[:default]
+          else
+            const name, prop_info[:type], default: prop_info[:default]
+          end
+        end
+        
+        # Add output fields  
+        output_props.each do |name, prop_info|
+          if prop_info[:rules]&.any? { |rule| rule.is_a?(T::Props::NilableRules) }
+            prop name, prop_info[:type], default: prop_info[:default]
+          else
+            const name, prop_info[:type], default: prop_info[:default]
+          end
+        end
+        
+        # Add to_h method to serialize the struct to a hash
+        define_method :to_h do
+          hash = {}
+          
+          # Add all properties
+          self.class.props.keys.each do |key|
+            hash[key] = self.send(key)
+          end
+          
+          hash
+        end
       end
-      raise PredictionInvalidError.new(result.errors)
     end
   end
 end