dspy 0.2.0 → 0.3.0

data/lib/dspy/sorbet_predict.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-require 'sorbet-runtime'
-require_relative 'sorbet_module'
-
-module DSPy
-  class SorbetPredict < DSPy::SorbetModule
-    extend T::Sig
-
-    sig { returns(T.class_of(SorbetSignature)) }
-    attr_reader :signature_class
-
-    sig { params(signature_class: T.class_of(SorbetSignature)).void }
-    def initialize(signature_class)
-      @signature_class = signature_class
-    end
-
-    sig { returns(String) }
-    def system_signature
-      <<-PROMPT
-      Your input schema fields are:
-        ```json
-         #{JSON.generate(@signature_class.input_json_schema)}
-        ```
-      Your output schema fields are:
-        ```json
-          #{JSON.generate(@signature_class.output_json_schema)}
-        ````
-      
-      For example, based on the schemas above, a valid interaction would be:
-      ## Input values
-        ```json
-          #{JSON.generate(generate_example_input)}
-        ```
-      ## Output values
-        ```json
-          #{JSON.generate(generate_example_output)}
-        ```
-      
-      All interactions will be structured in the following way, with the appropriate values filled in.
-
-      ## Input values
-        ```json
-         {input_values}
-        ```  
-      ## Output values
-      Respond exclusively with the output schema fields in the json block below.
-        ```json
-          {output_values}
-        ```
-      
-      In adhering to this structure, your objective is: #{@signature_class.description}
-
-      PROMPT
-    end
-
-    sig { returns(T::Hash[Symbol, T.untyped]) }
-    def generate_example_input
-      example = {}
-      @signature_class.input_struct_class.props.each do |name, prop|
-        example[name] = case prop[:type]
-        when T::Types::Simple
-          case prop[:type].raw_type.to_s
-          when "String" then "example text"
-          when "Integer" then 42
-          when "Float" then 3.14
-          else "example"
-          end
-        else
-          "example"
-        end
-      end
-      example
-    end
-
-    sig { returns(T::Hash[Symbol, T.untyped]) }
-    def generate_example_output
-      example = {}
-      @signature_class.output_struct_class.props.each do |name, prop|
-        example[name] = case prop[:type]
-        when T::Types::Simple
-          if prop[:type].raw_type < T::Enum
-            # Use the first enum value as example
-            prop[:type].raw_type.values.first.serialize
-          else
-            case prop[:type].raw_type.to_s
-            when "String" then "example result"
-            when "Integer" then 1
-            when "Float" then 0.95
-            else "example"
-            end
-          end
-        else
-          "example"
-        end
-      end
-      example
-    end
-
-    sig { params(input_values: T::Hash[Symbol, T.untyped]).returns(String) }
-    def user_signature(input_values)
-      <<-PROMPT
-        ## Input Values
-        ```json
-        #{JSON.generate(input_values)}
-        ```     
-        
-        Respond with the corresponding output schema fields wrapped in a ```json ``` block, 
-         starting with the heading `## Output values`.
-      PROMPT
-    end
-
-    sig { returns(DSPy::LM) }
-    def lm
-      DSPy.config.lm
-    end
-
-    sig { params(input_values: T.untyped).returns(T.untyped) }
-    def forward_untyped(**input_values)
-      DSPy.logger.info(module: self.class.to_s, **input_values)
-
-      # Validate input using T::Struct
-      begin
-        _input_struct = @signature_class.input_struct_class.new(**input_values)
-      rescue ArgumentError => e
-        raise PredictionInvalidError.new({ input: e.message })
-      end
-
-      # Use the original input_values since input_struct.to_h may not be available
-      # The input has already been validated through the struct instantiation
-      output_attributes = lm.chat(self, input_values)
-
-      # Debug: log what we got from LM
-      DSPy.logger.info("LM returned: #{output_attributes.inspect}")
-      DSPy.logger.info("Output attributes class: #{output_attributes.class}")
-
-      # Convert string keys to symbols
-      output_attributes = output_attributes.transform_keys(&:to_sym)
-
-      # Handle enum deserialization
-      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
-            # Deserialize enum value
-            [key, enum_class.deserialize(value)]
-          elsif prop_type == Float || (prop_type.is_a?(T::Types::Simple) && prop_type.raw_type == Float)
-            # Coerce to Float
-            [key, value.to_f]
-          elsif prop_type == Integer || (prop_type.is_a?(T::Types::Simple) && prop_type.raw_type == Integer)
-            # Coerce to Integer
-            [key, value.to_i]
-          else
-            [key, value]
-          end
-        else
-          [key, value]
-        end
-      end.to_h
-
-      # Create output struct with validation
-      begin
-        output_struct = @signature_class.output_struct_class.new(**output_attributes)
-        return output_struct
-      rescue ArgumentError => e
-        raise PredictionInvalidError.new({ output: e.message })
-      rescue TypeError => e
-        raise PredictionInvalidError.new({ output: e.message })
-      end
-    end
-  end
-end

data/lib/dspy/sorbet_re_act.rb

@@ -1,332 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require 'sorbet-runtime'
-require_relative 'sorbet_predict'
-require_relative 'sorbet_signature'
-require_relative 'sorbet_chain_of_thought'
-require 'json'
-
-module DSPy
-  # Define a simple struct for history entries with proper type annotations
-  class HistoryEntry < T::Struct
-    const :step, Integer
-    prop :thought, T.nilable(String)
-    prop :action, T.nilable(String)
-    prop :action_input, T.nilable(T.any(String, Numeric, T::Hash[T.untyped, T.untyped], T::Array[T.untyped]))
-    prop :observation, T.nilable(String)
-
-    # Custom serialization to ensure compatibility with the rest of the code
-    def to_h
-      {
-        step: step,
-        thought: thought,
-        action: action,
-        action_input: action_input,
-        observation: observation
-      }.compact
-    end
-  end
-  # Defines the signature for ReAct reasoning using Sorbet signatures
-  class SorbetThought < DSPy::SorbetSignature
-    description "Generate a thought about what to do next to answer the question."
-
-    input do
-      const :question, String,
-        description: "The question to answer"
-      const :history, T::Array[HistoryEntry],
-        description: "Previous thoughts and actions, including observations from tools. The agent MUST use information from the history to inform its actions and final answer. Each entry is a hash representing a step in the reasoning process."
-      const :available_tools, String,
-        description: "List of available tools and their JSON schemas. The agent MUST choose an action from this list or use \"finish\". For each tool, use the name exactly as specified and provide action_input as a JSON object matching the tool's schema."
-    end
-
-    output do
-      const :thought, String,
-        description: "Reasoning about what to do next, considering the history and observations."
-      const :action, String,
-        description: "The action to take. MUST be one of the tool names listed in `available_tools` input, or the literal string \"finish\" to provide the final answer."
-      const :action_input, T.any(String, T::Hash[T.untyped, T.untyped]),
-        description: "Input for the chosen action. If action is a tool name, this MUST be a JSON object matching the tool's schema. If action is \"finish\", this field MUST contain the final answer to the original question. This answer MUST be directly taken from the relevant Observation in the history if available. For example, if an observation showed \"Observation: 100.0\", and you are finishing, this field MUST be \"100.0\". Do not leave empty if finishing with an observed answer."
-    end
-  end
-
-  # ReAct Agent using Sorbet signatures
-  class SorbetReAct < SorbetPredict
-    extend T::Sig
-
-    sig { returns(T.class_of(DSPy::SorbetSignature)) }
-    attr_reader :original_signature_class
-
-    sig { returns(T.class_of(T::Struct)) }
-    attr_reader :enhanced_output_struct
-
-    sig { returns(T::Hash[String, T.untyped]) }
-    attr_reader :tools
-
-    sig { returns(Integer) }
-    attr_reader :max_iterations
-
-
-    sig { params(signature_class: T.class_of(DSPy::SorbetSignature), tools: T::Array[T.untyped], max_iterations: Integer).void }
-    def initialize(signature_class, tools: [], max_iterations: 5)
-      @original_signature_class = signature_class
-      @tools = T.let({}, T::Hash[String, T.untyped])
-      tools.each { |tool| @tools[tool.name.downcase] = tool }
-      @max_iterations = max_iterations
-
-      # Create thought generator using SorbetPredict to preserve field descriptions
-      @thought_generator = T.let(DSPy::SorbetPredict.new(SorbetThought), DSPy::SorbetPredict)
-
-      # Create enhanced output struct with ReAct fields
-      @enhanced_output_struct = create_enhanced_output_struct(signature_class)
-      enhanced_output_struct = @enhanced_output_struct
-
-      # Create enhanced signature class
-      enhanced_signature = Class.new(DSPy::SorbetSignature) do
-        # Set the description
-        description signature_class.description
-
-        # Use the same input struct
-        @input_struct_class = signature_class.input_struct_class
-
-        # Use the enhanced output struct with ReAct fields
-        @output_struct_class = enhanced_output_struct
-
-        class << self
-          attr_reader :input_struct_class, :output_struct_class
-        end
-      end
-
-      # Call parent constructor with enhanced signature
-      super(enhanced_signature)
-    end
-
-    sig { params(kwargs: T.untyped).returns(T.untyped) }
-    def forward(**kwargs)
-      # Validate input using Sorbet struct validation
-      input_struct = @original_signature_class.input_struct_class.new(**kwargs)
-
-      # Get the question (assume first field is the question for now)
-      question = T.cast(input_struct.serialize.values.first, String)
-
-      history = T.let([], T::Array[HistoryEntry])
-      available_tools_desc = @tools.map { |name, tool| "- #{name}: #{tool.schema}" }.join("\n")
-
-      final_answer = T.let(nil, T.nilable(String))
-      iterations_count = 0
-      last_observation = T.let(nil, T.nilable(String))
-      potential_answer = T.let(nil, T.nilable(String))
-
-      while @max_iterations.nil? || iterations_count < @max_iterations
-        iterations_count += 1
-
-        # Get next thought from LM
-        thought_obj = @thought_generator.forward(
-          question: question,
-          history: history,
-          available_tools: available_tools_desc
-        )
-
-        thought = thought_obj.thought
-        action = thought_obj.action
-        action_input = thought_obj.action_input
-
-        # Store this step in history
-        step = history.length + 1
-        current_entry = HistoryEntry.new(
-          step: step,
-          thought: thought,
-          action: action,
-          action_input: action_input
-        )
-        history << current_entry
-
-        if action.downcase == "finish"
-          # If action is finish, set the final answer
-          final_answer = action_input.to_s
-          
-          # If final_answer is empty but we have a last observation, use it
-          if (final_answer.nil? || final_answer.empty?) && last_observation
-            final_answer = last_observation
-            # Update the action_input for consistency by replacing the last entry
-            history.pop
-            history << HistoryEntry.new(
-              step: step,
-              thought: thought,
-              action: action,
-              action_input: final_answer
-            )
-          end
-          
-          break
-        end
-
-        # Execute action and get observation
-        observation = execute_action(action, action_input)
-        
-        # Store the raw observation for potential use as the final answer
-        last_observation = observation
-
-        # Update the entry with the observation by replacing it
-        history.pop
-        history << HistoryEntry.new(
-          step: step,
-          thought: thought,
-          action: action,
-          action_input: action_input,
-          observation: "Observation: #{observation}"
-        )
-        
-        # Special case for add_numbers tool - if the question is about addition and we got a numeric result
-        if action.downcase == "add_numbers" && 
-           question.downcase.include?("plus") &&
-           observation.to_s.match?(/^\d+(\.\d+)?$/)
-          # This looks like it might be the final answer to an addition question
-          potential_answer = observation.to_s
-        end
-      end
-
-      # If we reached max iterations without a finish action
-      if final_answer.nil?
-        # Try to extract answer from special cases we recognized
-        if defined?(potential_answer) && !potential_answer.nil?
-          final_answer = potential_answer
-        # Otherwise use the last observation as fallback
-        elsif last_observation
-          final_answer = last_observation
-        else
-          final_answer = "I was unable to determine the answer"
-        end
-        
-        # Add a finish step to history
-        step = history.length + 1
-        history << HistoryEntry.new(
-          step: step,
-          thought: "I've reached the maximum number of iterations and will provide the answer based on the tools I've used.",
-          action: "finish",
-          action_input: final_answer
-        )
-      end
-
-      # Create result with enhanced output struct
-      if @enhanced_output_struct
-        begin
-          # Get the first output field name from the original signature
-          output_field_name = @original_signature_class.output_struct_class.props.keys.first
-          
-          # Create enhanced output struct with answer and history
-          result = @enhanced_output_struct.new(
-            "#{output_field_name}": final_answer || "",
-            history: history.map(&:to_h),
-            iterations: iterations_count
-          )
-          
-          # Run validation
-          validate_output_schema!(result)
-          
-          result
-        rescue => e
-          puts "Error creating enhanced output: #{e.message}"
-          # Fall back to basic result
-          Struct.new(:answer, :history, :iterations).new(final_answer || "", history, iterations_count)
-        end
-      else
-        # Basic result for compatibility
-        Struct.new(:answer, :history, :iterations).new(final_answer || "", history, iterations_count)
-      end
-    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 ReAct fields 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 ReAct-specific fields
-        const :history, T::Array[T::Hash[Symbol, T.untyped]]
-        const :iterations, Integer
-      end
-    end
-
-    sig { params(action: String, action_input: T.untyped).returns(String) }
-    def execute_action(action, action_input)
-      tool_name = action.downcase
-      tool = @tools[tool_name]
-      return "Tool '#{action}' not found. Available tools: #{@tools.keys.join(', ')}" unless tool
-
-      begin
-        result = if action_input.nil? || 
-                   (action_input.is_a?(String) && action_input.strip.empty?)
-          # No input provided
-          tool.dynamic_call({})
-        else
-          # Pass the action_input directly to dynamic_call, which can handle
-          # either a Hash or a JSON string
-          tool.dynamic_call(action_input)
-        end
-        result.to_s
-      rescue => e
-        "Error executing tool '#{action}': #{e.message}"
-      end
-    end
-    
-    sig { params(output: T.untyped).void }
-    def validate_output_schema!(output)
-      # Validate that output is an instance of the enhanced output struct
-      unless output.is_a?(@enhanced_output_struct)
-        raise "Output must be an instance of #{@enhanced_output_struct}, got #{output.class}"
-      end
-
-      # Validate original signature output fields are present
-      @original_signature_class.output_struct_class.props.each do |field_name, _prop|
-        unless output.respond_to?(field_name)
-          raise "Missing required field: #{field_name}"
-        end
-      end
-
-      # Validate ReAct-specific fields
-      unless output.respond_to?(:history) && output.history.is_a?(Array)
-        raise "Missing or invalid history field"
-      end
-
-      unless output.respond_to?(:iterations) && output.iterations.is_a?(Integer)
-        raise "Missing or invalid iterations field"
-      end
-    end
-
-    sig { override.returns(T::Hash[Symbol, T.untyped]) }
-    def generate_example_output
-      example = super
-      example[:history] = [
-        {
-          step: 1,
-          thought: "I need to think about this question...",
-          action: "some_tool",
-          action_input: "input for tool",
-          observation: "result from tool"
-        }
-      ]
-      example[:iterations] = 1
-      example
-    end
-  end
-end