desiru 0.1.0

data/lib/desiru/models/raix_adapter.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+require 'raix'
+require 'faraday'
+require 'faraday/retry'
+require 'openai'
+
+module Desiru
+  module Models
+    # Adapter for Raix gem integration
+    # Provides unified interface to OpenAI, Anthropic, and OpenRouter via Raix
+    # Uses modern Raix patterns with direct OpenAI::Client configuration
+    class RaixAdapter < Base
+      def initialize(api_key: nil, provider: :openai, uri_base: nil, **config)
+        @api_key = api_key || fetch_api_key(provider)
+        @provider = provider
+        @uri_base = uri_base || fetch_uri_base(provider)
+
+        super(config)
+        configure_raix!
+      end
+
+      def complete(prompt, **options)
+        opts = build_completion_options(prompt, options)
+
+        response = with_retry do
+          client.completions.create(**opts)
+        end
+
+        process_response(response)
+      end
+
+      def stream_complete(prompt, **options)
+        opts = build_completion_options(prompt, options).merge(stream: true)
+
+        with_retry do
+          client.completions.create(**opts) do |chunk|
+            yield process_stream_chunk(chunk)
+          end
+        end
+      end
+
+      def models
+        case provider
+        when :openai
+          %w[gpt-4-turbo gpt-4 gpt-3.5-turbo gpt-4o gpt-4o-mini]
+        when :anthropic
+          %w[claude-3-opus-20240229 claude-3-sonnet-20240229 claude-3-haiku-20240307]
+        when :openrouter
+          # OpenRouter supports many models with provider prefixes
+          %w[anthropic/claude-3-opus openai/gpt-4-turbo google/gemini-pro meta-llama/llama-3-70b]
+        else
+          []
+        end
+      end
+
+      protected
+
+      def default_config
+        super.merge(
+          model: 'gpt-4-turbo-preview',
+          response_format: nil,
+          tools: nil,
+          tool_choice: nil
+        )
+      end
+
+      def build_client
+        # Modern Raix uses direct configuration, not separate client instances
+        # The client is accessed through Raix after configuration
+        ::Raix
+      end
+
+      def configure_raix!
+        ::Raix.configure do |raix_config|
+          raix_config.openai_client = build_openai_client
+        end
+      end
+
+      def build_openai_client
+        ::OpenAI::Client.new(
+          access_token: @api_key,
+          uri_base: @uri_base
+        ) do |f|
+          # Add retry middleware
+          f.request(:retry, {
+                      max: config[:max_retries] || 3,
+                      interval: 0.05,
+                      interval_randomness: 0.5,
+                      backoff_factor: 2
+                    })
+
+          # Add logging in debug mode
+          if ENV['DEBUG'] || config[:debug]
+            f.response(:logger, config[:logger] || Logger.new($stdout), {
+                         headers: false,
+                         bodies: true,
+                         errors: true
+                       }) do |logger|
+              logger.filter(/(Bearer) (\S+)/, '\1[REDACTED]')
+            end
+          end
+        end
+      end
+
+      def fetch_api_key(provider)
+        case provider
+        when :openai
+          ENV.fetch('OPENAI_API_KEY', nil)
+        when :anthropic
+          ENV.fetch('ANTHROPIC_API_KEY', nil)
+        when :openrouter
+          ENV.fetch('OPENROUTER_API_KEY', nil)
+        else
+          ENV.fetch("#{provider.to_s.upcase}_API_KEY", nil)
+        end
+      end
+
+      def fetch_uri_base(provider)
+        case provider
+        when :openai
+          ENV['OPENAI_API_BASE'] || 'https://api.openai.com/v1'
+        when :anthropic
+          ENV['ANTHROPIC_API_BASE'] || 'https://api.anthropic.com/v1'
+        when :openrouter
+          ENV['OPENROUTER_API_BASE'] || 'https://openrouter.ai/api/v1'
+        else
+          ENV.fetch("#{provider.to_s.upcase}_API_BASE", nil)
+        end
+      end
+
+      def validate_config!
+        raise ConfigurationError, 'API key is required' if @api_key.nil? || @api_key.empty?
+        raise ConfigurationError, 'Model must be specified' if config[:model].nil?
+      end
+
+      private
+
+      attr_reader :provider
+
+      def build_completion_options(prompt, options)
+        messages = build_messages(prompt, options[:demos] || [])
+
+        {
+          model: options[:model] || config[:model],
+          messages: messages,
+          temperature: options[:temperature] || config[:temperature],
+          max_tokens: options[:max_tokens] || config[:max_tokens],
+          response_format: options[:response_format] || config[:response_format],
+          tools: options[:tools] || config[:tools],
+          tool_choice: options[:tool_choice] || config[:tool_choice]
+        }.compact
+      end
+
+      def build_messages(prompt, demos)
+        messages = []
+
+        # Add system message if provided
+        messages << { role: 'system', content: prompt[:system] } if prompt[:system]
+
+        # Add demonstrations
+        demos.each do |demo|
+          messages << { role: 'user', content: demo[:input] }
+          messages << { role: 'assistant', content: demo[:output] }
+        end
+
+        # Add current prompt
+        messages << { role: 'user', content: prompt[:user] || prompt[:content] || prompt }
+
+        messages
+      end
+
+      def process_response(response)
+        content = response.dig('choices', 0, 'message', 'content')
+        usage = response['usage']
+
+        increment_stats(usage['total_tokens']) if usage
+
+        {
+          content: content,
+          raw: response,
+          model: response['model'],
+          usage: usage
+        }
+      end
+
+      def process_stream_chunk(chunk)
+        content = chunk.dig('choices', 0, 'delta', 'content')
+
+        {
+          content: content,
+          finished: chunk.dig('choices', 0, 'finish_reason').present?
+        }
+      end
+    end
+
+    # Convenience classes for specific providers
+    class OpenAI < RaixAdapter
+      def initialize(api_key: nil, **config)
+        super(api_key: api_key, provider: :openai, **config)
+      end
+    end
+
+    class OpenRouter < RaixAdapter
+      def initialize(api_key: nil, **config)
+        super(api_key: api_key, provider: :openrouter, **config)
+      end
+    end
+  end
+end

data/lib/desiru/module.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+# require_relative 'async_capable'
+
+module Desiru
+  # Base class for all Desiru modules
+  # Implements the core module pattern with service-oriented design
+  class Module
+    extend Forwardable
+    # include AsyncCapable
+
+    attr_reader :signature, :model, :config, :demos, :metadata
+
+    def initialize(signature, model: nil, config: {}, demos: [], metadata: {})
+      @signature = case signature
+                   when Signature
+                     signature
+                   when String
+                     Signature.new(signature)
+                   else
+                     raise ModuleError, 'Signature must be a String or Signature instance'
+                   end
+
+      @model = model || Desiru.configuration.default_model
+      @config = default_config.merge(config)
+      @demos = demos
+      @metadata = metadata
+      @call_count = 0
+
+      # Raise error if no model available
+      raise ArgumentError, 'No model provided and no default model configured' if @model.nil?
+
+      validate_model!
+      register_module
+    end
+
+    def call(inputs = {})
+      @call_count += 1
+      @retry_count = 0
+
+      begin
+        # Validate inputs first, then coerce
+        signature.validate_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)
+        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
+          @retry_count += 1
+          Desiru.configuration.logger&.warn("Retrying module execution (attempt #{@retry_count}/#{Desiru.configuration.max_retries})")
+          sleep(Desiru.configuration.retry_delay)
+          retry
+        else
+          handle_error(e)
+        end
+      end
+    end
+
+    def forward(_inputs)
+      raise NotImplementedError, 'Subclasses must implement #forward'
+    end
+
+    def reset
+      @demos = []
+      @call_count = 0
+    end
+
+    def with_demos(new_demos)
+      self.class.new(signature, model: model, config: config, demos: new_demos, metadata: metadata)
+    end
+
+    def to_h
+      {
+        class: self.class.name,
+        signature: signature.to_h,
+        config: config,
+        demos_count: demos.size,
+        call_count: @call_count,
+        metadata: metadata
+      }
+    end
+
+    protected
+
+    def default_config
+      {
+        temperature: 0.7,
+        max_tokens: 1000,
+        timeout: 30,
+        retry_on_failure: true
+      }
+    end
+
+    def execution_metadata
+      {
+        module: self.class.name,
+        call_count: @call_count,
+        demos_used: demos.size,
+        timestamp: Time.now
+      }
+    end
+
+    private
+
+    def validate_model!
+      return if model.nil? # Will use default
+
+      # Skip validation for test doubles/mocks
+      return if defined?(RSpec) && (model.is_a?(RSpec::Mocks::Double) || model.respond_to?(:_rspec_double))
+
+      return if model.respond_to?(:complete)
+
+      raise ConfigurationError, 'Model must respond to #complete'
+    end
+
+    def register_module
+      # Auto-register with the registry if configured
+      return unless Desiru.configuration.module_registry && metadata[:auto_register]
+
+      Desiru.configuration.module_registry.register(
+        self.class.name.split('::').last.downcase,
+        self.class,
+        metadata: metadata
+      )
+    end
+
+    def handle_error(error)
+      Desiru.configuration.logger&.error("Module execution failed: #{error.message}")
+      raise ModuleError, "Module execution failed: #{error.message}"
+    end
+  end
+
+  # Result object for module outputs
+  class ModuleResult
+    extend Forwardable
+
+    attr_reader :data, :metadata, :outputs
+
+    def_delegators :@data, :keys, :values, :each
+
+    def initialize(data = nil, metadata: {}, **kwargs)
+      # Support both positional and keyword arguments for backward compatibility
+      if data.nil? && !kwargs.empty?
+        @data = kwargs
+        @outputs = kwargs
+      else
+        @data = data || {}
+        @outputs = @data
+      end
+      @metadata = metadata
+    end
+
+    def [](key)
+      if @data.key?(key.to_sym)
+        @data[key.to_sym]
+      elsif @data.key?(key.to_s)
+        @data[key.to_s]
+      end
+    end
+
+    def method_missing(method_name, *args, &)
+      method_str = method_name.to_s
+      if method_str.end_with?('?')
+        # Handle predicate methods for boolean values
+        key = method_str[0..-2].to_sym
+        if data.key?(key)
+          return !!data[key]
+        elsif data.key?(key.to_s)
+          return !!data[key.to_s]
+        end
+      end
+
+      if data.key?(method_name.to_sym)
+        data[method_name.to_sym]
+      elsif data.key?(method_name.to_s)
+        data[method_name.to_s]
+      else
+        super
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      method_str = method_name.to_s
+      if method_str.end_with?('?')
+        key = method_str[0..-2]
+        data.key?(key.to_sym) || data.key?(key)
+      else
+        data.key?(method_name.to_sym) || data.key?(method_name.to_s) || super
+      end
+    end
+
+    def to_h
+      data
+    end
+  end
+end

data/lib/desiru/modules/chain_of_thought.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Desiru
+  module Modules
+    # Chain of Thought module - adds reasoning steps before producing outputs
+    class ChainOfThought < Predict
+      def initialize(signature, **)
+        # Extend signature to include reasoning field
+        extended_sig = extend_signature_with_reasoning(signature)
+        super(extended_sig, **)
+        @original_signature = signature
+      end
+
+      protected
+
+      def build_system_prompt
+        <<~PROMPT
+          You are a helpful AI assistant that thinks step by step. You will be given inputs and must produce outputs according to the following specification:
+
+          #{format_original_signature}
+
+          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]
+
+          #{format_descriptions}
+        PROMPT
+      end
+
+      def build_user_prompt(inputs)
+        lines = ['Given the following inputs:']
+
+        inputs.each do |key, value|
+          lines << "#{key}: #{format_value(value)}"
+        end
+
+        lines << "\nThink step by step and provide:"
+        lines << 'reasoning: (your thought process)'
+
+        @original_signature.output_fields.each_key do |key|
+          lines << "#{key}: (your answer)"
+        end
+
+        lines.join("\n")
+      end
+
+      def parse_response(content)
+        result = super
+
+        # Extract reasoning if not already captured
+        unless result[:reasoning]
+          reasoning_match = content.match(/reasoning:\s*(.+?)(?=\n\w+:|$)/mi)
+          result[:reasoning] = reasoning_match[1].strip if reasoning_match
+        end
+
+        # Ensure we have all original output fields
+        @original_signature.output_fields.each_key do |field|
+          result[field] ||= result[field.to_s]
+        end
+
+        result
+      end
+
+      private
+
+      def extend_signature_with_reasoning(signature)
+        sig_string = case signature
+                     when Signature
+                       signature.raw_signature
+                     when String
+                       signature
+                     else
+                       raise ModuleError, 'Invalid signature type'
+                     end
+
+        # Parse the signature parts
+        parts = sig_string.split('->').map(&:strip)
+        inputs = parts[0]
+        outputs = parts[1]
+
+        # Add reasoning to outputs if not already present
+        outputs = "reasoning: string, #{outputs}" unless outputs.include?('reasoning')
+
+        Signature.new("#{inputs} -> #{outputs}")
+      end
+
+      def format_original_signature
+        case @original_signature
+        when Signature
+          "#{format_fields(@original_signature.input_fields)} -> #{format_fields(@original_signature.output_fields)}"
+        when String
+          @original_signature
+        else
+          signature.raw_signature
+        end
+      end
+    end
+  end
+end
+
+# Register in the main module namespace for convenience
+module Desiru
+  ChainOfThought = Modules::ChainOfThought
+end

data/lib/desiru/modules/predict.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module Desiru
+  module Modules
+    # Basic prediction module - the fundamental building block
+    class Predict < Module
+      def forward(inputs)
+        prompt = build_prompt(inputs)
+
+        response = model.complete(
+          prompt,
+          temperature: config[:temperature],
+          max_tokens: config[:max_tokens],
+          demos: demos
+        )
+
+        parse_response(response[:content])
+      end
+
+      protected
+
+      def build_prompt(inputs)
+        {
+          system: build_system_prompt,
+          user: build_user_prompt(inputs)
+        }
+      end
+
+      def build_system_prompt
+        <<~PROMPT
+          You are a helpful AI assistant. You will be given inputs and must produce outputs according to the following specification:
+
+          #{format_signature}
+
+          Respond with only the requested output fields in a clear format.
+          #{format_descriptions}
+        PROMPT
+      end
+
+      def build_user_prompt(inputs)
+        lines = ['Given the following inputs:']
+
+        inputs.each do |key, value|
+          lines << "#{key}: #{format_value(value)}"
+        end
+
+        lines << "\nProvide the following outputs:"
+        signature.output_fields.each_key do |key|
+          lines << "#{key}:"
+        end
+
+        lines.join("\n")
+      end
+
+      def format_signature
+        "#{format_fields(signature.input_fields)} -> #{format_fields(signature.output_fields)}"
+      end
+
+      def format_fields(fields)
+        fields.map do |name, field|
+          type_str = field.type == :string ? '' : ": #{field.type}"
+          "#{name}#{type_str}"
+        end.join(', ')
+      end
+
+      def format_descriptions
+        descriptions = []
+
+        all_fields = signature.input_fields.merge(signature.output_fields)
+        all_fields.each do |name, field|
+          next unless field.description
+
+          descriptions << "- #{name}: #{field.description}"
+        end
+
+        return '' if descriptions.empty?
+
+        "\nField descriptions:\n#{descriptions.join("\n")}"
+      end
+
+      def format_value(value)
+        case value
+        when Array
+          value.map(&:to_s).join(', ')
+        when Hash
+          value.to_json
+        else
+          value.to_s
+        end
+      end
+
+      def parse_response(content)
+        # Simple parser - looks for key: value patterns
+        result = {}
+
+        signature.output_fields.each_key do |field_name|
+          # Look for the field name followed by a colon
+          pattern = /#{Regexp.escape(field_name.to_s)}:\s*(.+?)(?=\n\w+:|$)/mi
+          match = content.match(pattern)
+
+          if match
+            value = match[1].strip
+            result[field_name] = parse_field_value(field_name, value)
+          end
+        end
+
+        result
+      end
+
+      def parse_field_value(field_name, value_str)
+        field = signature.output_fields[field_name]
+        return value_str unless field
+
+        case field.type
+        when :int
+          value_str.to_i
+        when :float
+          value_str.to_f
+        when :bool
+          %w[true yes 1].include?(value_str.downcase)
+        when :list
+          # Simple list parsing - comma separated
+          value_str.split(',').map(&:strip)
+        when :hash
+          # Try to parse as JSON
+          begin
+            JSON.parse(value_str)
+          rescue StandardError
+            value_str
+          end
+        else
+          value_str
+        end
+      end
+    end
+  end
+end
+
+# Register in the main module namespace for convenience
+module Desiru
+  Predict = Modules::Predict
+end