desiru 0.1.0 → 0.1.1

data/lib/desiru/models/open_router.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'open_router'
+
+module Desiru
+  module Models
+    # OpenRouter model adapter - provides access to multiple models through a single API
+    class OpenRouter < Base
+      DEFAULT_MODEL = 'anthropic/claude-3-haiku'
+
+      def initialize(config = {})
+        super
+        @api_key = config[:api_key] || ENV.fetch('OPENROUTER_API_KEY', nil)
+        raise ArgumentError, 'OpenRouter API key is required' unless @api_key
+
+        # Configure OpenRouter client
+        ::OpenRouter.configure do |c|
+          c.access_token = @api_key
+          c.site_name = config[:site_name] || 'Desiru'
+          c.site_url = config[:site_url] || 'https://github.com/obie/desiru'
+        end
+
+        @client = ::OpenRouter::Client.new
+        @models_cache = nil
+        @models_fetched_at = nil
+      end
+
+      def models
+        # Cache models for 1 hour
+        fetch_models if @models_cache.nil? || @models_fetched_at.nil? || (Time.now - @models_fetched_at) > 3600
+        @models_cache
+      end
+
+      protected
+
+      def perform_completion(messages, options)
+        model = options[:model] || @config[:model] || DEFAULT_MODEL
+        temperature = options[:temperature] || @config[:temperature] || 0.7
+        max_tokens = options[:max_tokens] || @config[:max_tokens] || 4096
+
+        # Prepare request parameters
+        params = {
+          model: model,
+          messages: messages,
+          temperature: temperature,
+          max_tokens: max_tokens
+        }
+
+        # Add provider-specific options if needed
+        params[:provider] = options[:provider] if options[:provider]
+
+        # Add response format if specified
+        params[:response_format] = options[:response_format] if options[:response_format]
+
+        # Add tools if provided (for models that support function calling)
+        if options[:tools]
+          params[:tools] = options[:tools]
+          params[:tool_choice] = options[:tool_choice] if options[:tool_choice]
+        end
+
+        # Make API call
+        response = @client.complete(params)
+
+        # Format response
+        format_response(response, model)
+      rescue StandardError => e
+        handle_api_error(e)
+      end
+
+      def stream_complete(prompt, **options, &block)
+        messages = prepare_messages(prompt, options[:messages])
+        model = options[:model] || @config[:model] || DEFAULT_MODEL
+        temperature = options[:temperature] || @config[:temperature] || 0.7
+        max_tokens = options[:max_tokens] || @config[:max_tokens] || 4096
+
+        # Prepare streaming request
+        params = {
+          model: model,
+          messages: messages,
+          temperature: temperature,
+          max_tokens: max_tokens,
+          stream: true
+        }
+
+        # Stream response
+        @client.complete(params) do |chunk|
+          if chunk.dig('choices', 0, 'delta', 'content')
+            content = chunk.dig('choices', 0, 'delta', 'content')
+            block.call(content) if block_given?
+          end
+        end
+      rescue StandardError => e
+        handle_api_error(e)
+      end
+
+      private
+
+      def fetch_models
+        # OpenRouter provides models at https://openrouter.ai/api/v1/models
+        response = @client.models
+
+        @models_cache = {}
+        response['data'].each do |model|
+          @models_cache[model['id']] = {
+            name: model['name'] || model['id'],
+            context_length: model['context_length'],
+            pricing: model['pricing'],
+            top_provider: model['top_provider']
+          }
+        end
+
+        @models_fetched_at = Time.now
+        @models_cache
+      rescue StandardError => e
+        Desiru.logger.warn("Failed to fetch OpenRouter models: #{e.message}")
+        # Fallback to commonly used models
+        @models_cache = {
+          'anthropic/claude-3-haiku' => { name: 'Claude 3 Haiku' },
+          'anthropic/claude-3-sonnet' => { name: 'Claude 3 Sonnet' },
+          'openai/gpt-4o-mini' => { name: 'GPT-4o Mini' },
+          'openai/gpt-4o' => { name: 'GPT-4o' },
+          'google/gemini-pro' => { name: 'Gemini Pro' }
+        }
+        @models_fetched_at = Time.now
+        @models_cache
+      end
+
+      def format_response(response, model)
+        # OpenRouter uses OpenAI-compatible response format
+        content = response.dig('choices', 0, 'message', 'content') || ''
+        usage = response['usage'] || {}
+
+        {
+          content: content,
+          raw: response,
+          model: model,
+          usage: {
+            prompt_tokens: usage['prompt_tokens'] || 0,
+            completion_tokens: usage['completion_tokens'] || 0,
+            total_tokens: usage['total_tokens'] || 0
+          }
+        }
+      end
+
+      def handle_api_error(error)
+        case error
+        when ::Faraday::UnauthorizedError
+          raise AuthenticationError, 'Invalid OpenRouter API key'
+        when ::Faraday::BadRequestError
+          raise InvalidRequestError, "Invalid request: #{error.message}"
+        when ::Faraday::TooManyRequestsError
+          raise RateLimitError, 'OpenRouter API rate limit exceeded'
+        when ::Faraday::PaymentRequiredError
+          raise APIError, 'OpenRouter payment required - check your account balance'
+        else
+          raise APIError, "OpenRouter API error: #{error.message}"
+        end
+      end
+    end
+  end
+end

data/lib/desiru/module.rb

@@ -1,13 +1,14 @@
 # frozen_string_literal: true
 
-# require_relative 'async_capable'
+require_relative 'async_capable'
+require_relative 'assertions'
 
 module Desiru
   # Base class for all Desiru modules
   # Implements the core module pattern with service-oriented design
   class Module
     extend Forwardable
-    # include AsyncCapable
+    include AsyncCapable
 
     attr_reader :signature, :model, :config, :demos, :metadata
 
@@ -40,23 +41,23 @@ module Desiru
 
       begin
         # Validate inputs first, then coerce
-        signature.validate_inputs(inputs)
+        signature.valid_inputs?(inputs)
         coerced_inputs = signature.coerce_inputs(inputs)
 
         # Execute the module logic
         result = forward(**coerced_inputs)
 
         # Validate outputs first, then coerce
-        signature.validate_outputs(result)
+        signature.valid_outputs?(result)
         coerced_outputs = signature.coerce_outputs(result)
 
         # Return result object
         ModuleResult.new(coerced_outputs, metadata: execution_metadata)
       rescue StandardError => e
-        if config[:retry_on_failure] && @retry_count < Desiru.configuration.max_retries
+        if should_retry?(e)
           @retry_count += 1
-          Desiru.configuration.logger&.warn("Retrying module execution (attempt #{@retry_count}/#{Desiru.configuration.max_retries})")
-          sleep(Desiru.configuration.retry_delay)
+          log_retry(e)
+          sleep(retry_delay_for(e))
           retry
         else
           handle_error(e)
@@ -110,6 +111,44 @@ module Desiru
 
     private
 
+    def should_retry?(error)
+      return false unless config[:retry_on_failure]
+
+      # Handle assertion errors specifically
+      return error.retriable? && @retry_count < max_retries_for(error) if error.is_a?(Assertions::AssertionError)
+
+      # Default retry logic for other errors
+      @retry_count < Desiru.configuration.max_retries
+    end
+
+    def max_retries_for(error)
+      if error.is_a?(Assertions::AssertionError)
+        Assertions.configuration.max_assertion_retries
+      else
+        Desiru.configuration.max_retries
+      end
+    end
+
+    def retry_delay_for(error)
+      if error.is_a?(Assertions::AssertionError)
+        Assertions.configuration.assertion_retry_delay
+      else
+        Desiru.configuration.retry_delay
+      end
+    end
+
+    def log_retry(error)
+      if error.is_a?(Assertions::AssertionError)
+        Desiru.configuration.logger&.warn(
+          "[ASSERTION RETRY] #{error.message} (attempt #{@retry_count}/#{max_retries_for(error)})"
+        )
+      else
+        Desiru.configuration.logger&.warn(
+          "Retrying module execution (attempt #{@retry_count}/#{Desiru.configuration.max_retries})"
+        )
+      end
+    end
+
     def validate_model!
       return if model.nil? # Will use default
 
@@ -133,8 +172,19 @@ module Desiru
     end
 
     def handle_error(error)
-      Desiru.configuration.logger&.error("Module execution failed: #{error.message}")
-      raise ModuleError, "Module execution failed: #{error.message}"
+      if error.is_a?(Assertions::AssertionError)
+        # Update the assertion error with module context
+        error.instance_variable_set(:@module_name, self.class.name)
+        error.instance_variable_set(:@retry_count, @retry_count)
+
+        Desiru.configuration.logger&.error(
+          "[ASSERTION FAILED] #{error.message} in #{self.class.name} after #{@retry_count} retries"
+        )
+        raise error
+      else
+        Desiru.configuration.logger&.error("Module execution failed: #{error.message}")
+        raise ModuleError, "Module execution failed: #{error.message}"
+      end
     end
   end
 

data/lib/desiru/modules/chain_of_thought.rb

@@ -21,9 +21,9 @@ module Desiru
 
           Before providing the final answer, you must show your reasoning process. Think through the problem step by step.
 
-          Format your response as:
-          reasoning: [Your step-by-step thought process]
-          [output fields]: [Your final answers]
+          Always format your response with each field on its own line like this:
+          reasoning: Your step-by-step thought process here
+          #{@original_signature.output_fields.keys.map { |field| "#{field}: Your #{field} here" }.join("\n")}
 
           #{format_descriptions}
         PROMPT

data/lib/desiru/modules/majority.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Desiru
+  module Modules
+    # Function-style module for majority voting
+    # Returns the most common response from multiple completions
+    def self.majority(module_instance, **inputs)
+      raise ArgumentError, "First argument must be a Desiru module instance" unless module_instance.respond_to?(:call)
+
+      # Number of completions to generate
+      num_completions = inputs.delete(:num_completions) || 5
+
+      # Generate multiple completions
+      results = []
+      num_completions.times do
+        result = module_instance.call(**inputs)
+        results << result
+      end
+
+      # Find the majority answer
+      # For simplicity, we'll compare the first output field
+      output_fields = module_instance.signature.output_fields.keys
+      main_field = output_fields.first
+
+      # Count occurrences of each answer
+      answer_counts = Hash.new(0)
+      answer_to_result = {}
+
+      results.each do |result|
+        answer = result[main_field]
+        answer_counts[answer] += 1
+        answer_to_result[answer] ||= result
+      end
+
+      # Return the result with the most common answer
+      majority_answer = answer_counts.max_by { |_, count| count }&.first
+      winning_result = answer_to_result[majority_answer] || results.first
+
+      # Add voting metadata if requested
+      if output_fields.include?(:voting_data)
+        winning_result[:voting_data] = {
+          votes: answer_counts,
+          num_completions: num_completions,
+          consensus_rate: answer_counts[majority_answer].to_f / num_completions
+        }
+      end
+
+      winning_result
+    end
+  end
+end

data/lib/desiru/modules/multi_chain_comparison.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+module Desiru
+  module Modules
+    # MultiChainComparison module that generates multiple chain-of-thought
+    # reasoning paths and compares them to produce the best answer
+    class MultiChainComparison < Desiru::Module
+      def initialize(signature = nil, model: nil, **kwargs)
+        super
+        @num_chains = kwargs[:num_chains] || 3
+        @comparison_strategy = kwargs[:comparison_strategy] || :vote
+        @temperature = kwargs[:temperature] || 0.7
+      end
+
+      def forward(**inputs)
+        # Generate multiple reasoning chains
+        chains = generate_chains(inputs)
+
+        # Compare chains to determine best answer
+        best_result = case @comparison_strategy
+                      when :vote
+                        vote_on_chains(chains)
+                      when :llm_judge
+                        llm_judge_chains(chains, inputs)
+                      when :confidence
+                        select_by_confidence(chains)
+                      else
+                        chains.first # Fallback to first chain
+                      end
+
+        # Include comparison metadata if requested
+        if signature.output_fields.key?(:comparison_data)
+          best_result[:comparison_data] = {
+            num_chains: chains.length,
+            strategy: @comparison_strategy,
+            all_chains: chains.map { |c| c[:reasoning] }
+          }
+        end
+
+        best_result
+      end
+
+      private
+
+      def generate_chains(inputs)
+        chains = []
+
+        @num_chains.times do |i|
+          chain_prompt = build_chain_prompt(inputs, i)
+
+          response = model.complete(
+            messages: [{ role: 'user', content: chain_prompt }],
+            temperature: @temperature
+          )
+
+          chain_result = parse_chain_response(response[:content])
+          chains << chain_result
+        end
+
+        chains
+      end
+
+      def build_chain_prompt(inputs, chain_index)
+        prompt = "Please solve this problem step by step (Approach #{chain_index + 1}):\n\n"
+
+        # Add inputs
+        inputs.each do |key, value|
+          prompt += "#{key}: #{value}\n"
+        end
+
+        prompt += "\nProvide your reasoning step by step, then give your final answer.\n"
+        prompt += "Format your response as:\n"
+        prompt += "REASONING: [Your step-by-step reasoning]\n"
+        prompt += "ANSWER: [Your final answer]\n"
+
+        # Add output field descriptions
+        if signature.output_fields.any?
+          prompt += "\nMake sure your answer includes:\n"
+          signature.output_fields.each do |name, field|
+            next if %i[reasoning comparison_data].include?(name)
+
+            prompt += "- #{name}: #{field.description || field.type}\n"
+          end
+        end
+
+        prompt
+      end
+
+      def parse_chain_response(response)
+        result = {}
+
+        # Extract reasoning
+        reasoning_match = response.match(/REASONING:\s*(.+?)(?=ANSWER:|$)/mi)
+        result[:reasoning] = reasoning_match ? reasoning_match[1].strip : response
+
+        # Extract answer
+        answer_match = response.match(/ANSWER:\s*(.+)/mi)
+        answer_text = answer_match ? answer_match[1].strip : ""
+
+        # Try to parse structured answer
+        if answer_text.include?(':') || answer_text.include?('{')
+          result.merge!(parse_structured_answer(answer_text))
+        else
+          # Single value answer
+          main_output_field = signature.output_fields.keys.find { |k| !%i[reasoning comparison_data].include?(k) }
+          result[main_output_field] = answer_text if main_output_field
+        end
+
+        result
+      end
+
+      def parse_structured_answer(answer_text)
+        parsed = {}
+
+        # Try to parse as key-value pairs
+        answer_text.scan(/(\w+):\s*([^\n,}]+)/).each do |key, value|
+          key_sym = key.downcase.to_sym
+          parsed[key_sym] = value.strip if signature.output_fields.key?(key_sym)
+        end
+
+        parsed
+      end
+
+      def vote_on_chains(chains)
+        # Count votes for each unique answer
+        votes = Hash.new(0)
+        answer_to_chain = {}
+
+        chains.each do |chain|
+          # Get the main answer field (first non-metadata field)
+          answer_key = signature.output_fields.keys.find { |k| !%i[reasoning comparison_data].include?(k) }
+          answer_value = chain[answer_key]
+
+          if answer_value
+            votes[answer_value] += 1
+            answer_to_chain[answer_value] ||= chain
+          end
+        end
+
+        # Return the chain with the most common answer
+        winning_answer = votes.max_by { |_, count| count }&.first
+        answer_to_chain[winning_answer] || chains.first
+      end
+
+      def llm_judge_chains(chains, original_inputs)
+        judge_prompt = "Given the following problem and multiple solution attempts, select the best answer:\n\n"
+
+        # Add original inputs
+        judge_prompt += "Original Problem:\n"
+        original_inputs.each do |key, value|
+          judge_prompt += "#{key}: #{value}\n"
+        end
+
+        # Add all chains
+        judge_prompt += "\nSolution Attempts:\n"
+        chains.each_with_index do |chain, i|
+          judge_prompt += "\n--- Attempt #{i + 1} ---\n"
+          judge_prompt += "Reasoning: #{chain[:reasoning]}\n"
+
+          answer_key = signature.output_fields.keys.find { |k| !%i[reasoning comparison_data].include?(k) }
+          judge_prompt += "Answer: #{chain[answer_key]}\n" if chain[answer_key]
+        end
+
+        judge_prompt += "\nSelect the best attempt (1-#{chains.length}) and explain why:"
+
+        response = model.complete(
+          messages: [{ role: 'user', content: judge_prompt }],
+          temperature: 0.1 # Low temperature for more consistent judgment
+        )
+
+        # Extract selected chain index
+        selection_match = response[:content].match(/(?:attempt|option|choice)\s*#?(\d+)/i)
+        selected_index = selection_match ? selection_match[1].to_i - 1 : 0
+        selected_index = selected_index.clamp(0, chains.length - 1)
+
+        chains[selected_index]
+      end
+
+      def select_by_confidence(chains)
+        # Ask model to rate confidence for each chain
+        chains_with_confidence = chains.map do |chain|
+          confidence_prompt = "Rate your confidence (0-100) in this reasoning and answer:\n"
+          confidence_prompt += "Reasoning: #{chain[:reasoning]}\n"
+
+          answer_key = signature.output_fields.keys.find { |k| !%i[reasoning comparison_data].include?(k) }
+          confidence_prompt += "Answer: #{chain[answer_key]}\n" if chain[answer_key]
+
+          confidence_prompt += "\nRespond with just a number between 0 and 100:"
+
+          response = model.complete(
+            messages: [{ role: 'user', content: confidence_prompt }],
+            temperature: 0.1
+          )
+
+          confidence = response[:content].scan(/\d+/).first&.to_i || 50
+          chain.merge(confidence: confidence)
+        end
+
+        # Select chain with highest confidence
+        chains_with_confidence.max_by { |c| c[:confidence] }
+      end
+    end
+  end
+end

data/lib/desiru/modules/predict.rb

@@ -14,6 +14,8 @@ module Desiru
           demos: demos
         )
 
+        Desiru.logger.info("Predict response: #{response}")
+
         parse_response(response[:content])
       end
 
@@ -32,7 +34,12 @@ module Desiru
 
           #{format_signature}
 
-          Respond with only the requested output fields in a clear format.
+          Format your response with each output field on its own line using the pattern:
+          field_name: value
+
+          For example, if the output field is "answer", write:
+          answer: Your answer here
+
           #{format_descriptions}
         PROMPT
       end