rails_ai 0.1.0

data/lib/rails_ai/events.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RailsAi
+  module Events
+    def self.log!(kind:, name:, payload: {}, latency_ms: nil)
+      ActiveSupport::Notifications.instrument("rails_ai.#{kind}", {name:, payload:, latency_ms:, user_id: RailsAi::Context.user_id, request_id: RailsAi::Context.request_id})
+    end
+  end
+end

data/lib/rails_ai/image_context.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RailsAi
+  class ImageContext
+    attr_reader :metadata, :source, :dimensions, :file_size, :format, :created_at
+
+    def initialize(image_data, metadata: {})
+      @metadata = metadata || {}
+      @source = determine_source(image_data)
+      @dimensions = extract_dimensions(image_data)
+      @file_size = extract_file_size(image_data)
+      @format = extract_format(image_data)
+      @created_at = current_time
+    end
+
+    def to_h
+      {
+        source: source,
+        dimensions: dimensions,
+        file_size: file_size,
+        format: format,
+        created_at: created_at.iso8601,
+        metadata: metadata,
+        analysis_ready: analysis_ready?
+      }
+    end
+
+    def analysis_ready?
+      dimensions.present? && format.present?
+    end
+
+    def self.from_file(image_file)
+      new(image_file, metadata: extract_file_metadata(image_file))
+    end
+
+    def self.from_url(image_url)
+      new(image_url, metadata: { url: image_url })
+    end
+
+    def self.from_base64(image_data)
+      new(image_data, metadata: { encoding: 'base64' })
+    end
+
+    private
+
+    def current_time
+      if defined?(Time.current)
+        Time.current
+      else
+        Time.now
+      end
+    end
+
+    def determine_source(image_data)
+      case image_data
+      when String
+        if image_data.start_with?('data:')
+          'base64'
+        elsif image_data.start_with?('http')
+          'url'
+        else
+          'file_path'
+        end
+      when File, ActionDispatch::Http::UploadedFile
+        'uploaded_file'
+      else
+        'unknown'
+      end
+    end
+
+    def extract_dimensions(image_data)
+      # This would need to be implemented with image processing library
+      # For now, return placeholder
+      { width: 'unknown', height: 'unknown' }
+    end
+
+    def extract_file_size(image_data)
+      case image_data
+      when String
+        image_data.bytesize
+      when File, ActionDispatch::Http::UploadedFile
+        image_data.size
+      else
+        'unknown'
+      end
+    end
+
+    def extract_format(image_data)
+      case image_data
+      when String
+        if image_data.start_with?('data:')
+          image_data.split(';')[0].split(':')[1]
+        else
+          File.extname(image_data).downcase[1..-1]
+        end
+      when File, ActionDispatch::Http::UploadedFile
+        image_data.content_type&.split('/')&.last
+      else
+        'unknown'
+      end
+    end
+
+    def self.extract_file_metadata(image_file)
+      {
+        filename: image_file.respond_to?(:original_filename) ? image_file.original_filename : 'unknown',
+        content_type: image_file.respond_to?(:content_type) ? image_file.content_type : 'unknown'
+      }
+    end
+  end
+end

data/lib/rails_ai/performance.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+module RailsAi
+  module Performance
+    # Connection pooling for HTTP clients
+    class ConnectionPool
+      def initialize(size: 10)
+        @pool = Concurrent::Array.new(size) { create_connection }
+        @semaphore = Concurrent::Semaphore.new(size)
+      end
+
+      def with_connection
+        @semaphore.acquire
+        connection = @pool.pop
+        yield(connection)
+      ensure
+        @pool.push(connection) if connection
+        @semaphore.release
+      end
+
+      private
+
+      def create_connection
+        # Simple connection object for now
+        Object.new
+      end
+    end
+
+    # Request batching for multiple operations
+    class BatchProcessor
+      def initialize(batch_size: 10, flush_interval: 0.1)
+        @batch_size = batch_size
+        @flush_interval = flush_interval
+        @queue = Concurrent::Array.new
+        @mutex = Mutex.new
+        @last_flush = Time.now
+      end
+
+      def add_operation(operation)
+        @mutex.synchronize do
+          @queue << operation
+          flush_if_needed
+        end
+      end
+
+      private
+
+      def flush_if_needed
+        return unless should_flush?
+
+        operations = @queue.shift(@batch_size)
+        process_batch(operations) if operations.any?
+        @last_flush = Time.now
+      end
+
+      def should_flush?
+        @queue.size >= @batch_size || 
+        (Time.now - @last_flush) > @flush_interval
+      end
+
+      def process_batch(operations)
+        # Process operations in parallel
+        operations.map do |operation|
+          Concurrent::Future.execute { operation.call }
+        end.each(&:value!)
+      end
+    end
+
+    # Memory-efficient streaming
+    class StreamProcessor
+      def initialize(chunk_size: 1024)
+        @chunk_size = chunk_size
+      end
+
+      def process_stream(stream, &block)
+        buffer = String.new(capacity: @chunk_size)
+        
+        stream.each_chunk(@chunk_size) do |chunk|
+          buffer << chunk
+          
+          if buffer.bytesize >= @chunk_size
+            yield(buffer.dup)
+            buffer.clear
+          end
+        end
+        
+        yield(buffer) if buffer.bytesize > 0
+      end
+    end
+
+    # Smart caching with compression
+    class SmartCache
+      def initialize(compression_threshold: 1024)
+        @compression_threshold = compression_threshold
+      end
+
+      def fetch(key, **opts, &block)
+        return block.call unless block_given?
+
+        if defined?(Rails) && Rails.cache
+          compressed_key = compress_key(key)
+          Rails.cache.fetch(compressed_key, **opts) do
+            result = block.call
+            compress_if_needed(result)
+          end
+        else
+          block.call
+        end
+      end
+
+      private
+
+      def compress_key(key)
+        # Use consistent hashing for better distribution
+        Digest::MD5.hexdigest(key.inspect)
+      end
+
+      def compress_if_needed(data)
+        return data unless data.is_a?(String) && data.bytesize > @compression_threshold
+        
+        compressed = Zlib::Deflate.deflate(data)
+        { compressed: true, data: compressed }
+      end
+
+      def decompress_if_needed(data)
+        return data unless data.is_a?(Hash) && data[:compressed]
+        
+        Zlib::Inflate.inflate(data[:data])
+      end
+    end
+
+    # Request deduplication
+    class RequestDeduplicator
+      def initialize
+        @pending_requests = Concurrent::Hash.new
+        @mutex = Mutex.new
+      end
+
+      def deduplicate(key, &block)
+        @mutex.synchronize do
+          if @pending_requests[key]
+            # Wait for existing request
+            @pending_requests[key].value
+          else
+            # Start new request
+            future = Concurrent::Future.execute(&block)
+            @pending_requests[key] = future
+            
+            begin
+              future.value
+            ensure
+              @pending_requests.delete(key)
+            end
+          end
+        end
+      end
+    end
+
+    # Performance monitoring
+    class PerformanceMonitor
+      def initialize
+        @metrics = Concurrent::Hash.new
+      end
+
+      def measure(operation, &block)
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        memory_before = memory_usage
+        
+        result = block.call
+        
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+        memory_after = memory_usage
+        
+        record_metric(operation, duration, memory_after - memory_before)
+        result
+      end
+
+      def metrics
+        @metrics.dup
+      end
+
+      private
+
+      def record_metric(operation, duration, memory_delta)
+        @metrics[operation] ||= {
+          count: 0,
+          total_duration: 0.0,
+          total_memory: 0,
+          min_duration: Float::INFINITY,
+          max_duration: 0.0
+        }
+        
+        metric = @metrics[operation]
+        metric[:count] += 1
+        metric[:total_duration] += duration
+        metric[:total_memory] += memory_delta
+        metric[:min_duration] = [metric[:min_duration], duration].min
+        metric[:max_duration] = [metric[:max_duration], duration].max
+      end
+
+      def memory_usage
+        `ps -o rss= -p #{Process.pid}`.to_i * 1024
+      rescue
+        0
+      end
+    end
+
+    # Lazy loading for providers
+    class LazyProvider
+      def initialize(&provider_factory)
+        @provider_factory = provider_factory
+        @provider = nil
+        @mutex = Mutex.new
+      end
+
+      def method_missing(method, *args, **kwargs, &block)
+        @mutex.synchronize do
+          @provider ||= @provider_factory.call
+        end
+        @provider.public_send(method, *args, **kwargs, &block)
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @mutex.synchronize do
+          @provider ||= @provider_factory.call
+        end
+        @provider.respond_to?(method, include_private)
+      end
+    end
+  end
+end

data/lib/rails_ai/provider.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module RailsAi
+  class Provider
+    class RateLimited < StandardError; end
+    class UnsafeInputError < StandardError; end
+  end
+end

data/lib/rails_ai/providers/anthropic_adapter.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "base64"
+
+module RailsAi
+  module Providers
+    class AnthropicAdapter < Base
+      ANTHROPIC_API_BASE = "https://api.anthropic.com/v1"
+      
+      def initialize
+        @api_key = ENV.fetch("ANTHROPIC_API_KEY")
+        super
+      end
+
+      # Text-based operations
+      def chat!(messages:, model:, **opts)
+        return "(stubbed) #{messages.last[:content]}" if RailsAi.config.stub_responses
+        
+        # Convert OpenAI format to Anthropic format
+        anthropic_messages = convert_messages_to_anthropic(messages)
+        
+        response = make_request(
+          "messages",
+          {
+            model: model,
+            max_tokens: opts[:max_tokens] || RailsAi.config.token_limit,
+            messages: anthropic_messages,
+            temperature: opts[:temperature] || 1.0,
+            top_p: opts[:top_p] || 1.0,
+            top_k: opts[:top_k] || 0,
+            stop_sequences: opts[:stop_sequences] || [],
+            **opts.except(:max_tokens, :temperature, :top_p, :top_k, :stop_sequences)
+          }
+        )
+        
+        response.dig("content", 0, "text")
+      end
+
+      def stream_chat!(messages:, model:, **opts, &on_token)
+        return on_token.call("(stubbed stream)") if RailsAi.config.stub_responses
+        
+        # Convert OpenAI format to Anthropic format
+        anthropic_messages = convert_messages_to_anthropic(messages)
+        
+        make_streaming_request(
+          "messages",
+          {
+            model: model,
+            max_tokens: opts[:max_tokens] || RailsAi.config.token_limit,
+            messages: anthropic_messages,
+            temperature: opts[:temperature] || 1.0,
+            top_p: opts[:top_p] || 1.0,
+            top_k: opts[:top_k] || 0,
+            stop_sequences: opts[:stop_sequences] || [],
+            stream: true,
+            **opts.except(:max_tokens, :temperature, :top_p, :top_k, :stop_sequences, :stream)
+          }
+        ) do |chunk|
+          text = chunk.dig("delta", "text")
+          on_token.call(text) if text
+        end
+      end
+
+      def embed!(texts:, model:, **opts)
+        return Array.new(texts.length) { [0.0] * 1024 } if RailsAi.config.stub_responses
+        
+        # Anthropic doesn't have a direct embedding API, but we can use their models
+        # This is a placeholder implementation that could be enhanced
+        texts.map do |text|
+          # In a real implementation, you might use a different service for embeddings
+          # or implement a workaround using Claude's text understanding
+          Array.new(1024) { rand(-1.0..1.0) }
+        end
+      end
+
+      # Image generation - Anthropic doesn't have image generation
+      def generate_image!(prompt:, model:, **opts)
+        return "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==" if RailsAi.config.stub_responses
+        raise NotImplementedError, "Anthropic doesn't support image generation. Use OpenAI or Gemini for image generation."
+      end
+
+      def edit_image!(image:, prompt:, **opts)
+        return "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==" if RailsAi.config.stub_responses
+        raise NotImplementedError, "Anthropic doesn't support image editing. Use OpenAI or Gemini for image editing."
+      end
+
+      def create_variation!(image:, **opts)
+        return "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==" if RailsAi.config.stub_responses
+        raise NotImplementedError, "Anthropic doesn't support image variations. Use OpenAI or Gemini for image variations."
+      end
+
+      # Video generation - Anthropic doesn't have video generation
+      def generate_video!(prompt:, model:, **opts)
+        return "data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAAAB1tZGF0AQAAARxtYXNrAAAAAG1wNDEAAAAAIG1kYXQ=" if RailsAi.config.stub_responses
+        raise NotImplementedError, "Anthropic doesn't support video generation. Use OpenAI or Gemini for video generation."
+      end
+
+      def edit_video!(video:, prompt:, **opts)
+        return "data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAAAB1tZGF0AQAAARxtYXNrAAAAAG1wNDEAAAAAIG1kYXQ=" if RailsAi.config.stub_responses
+        raise NotImplementedError, "Anthropic doesn't support video editing. Use OpenAI or Gemini for video editing."
+      end
+
+      # Audio generation - Anthropic doesn't have audio generation
+      def generate_speech!(text:, model:, **opts)
+        return "data:audio/mp3;base64,SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU4Ljc2LjEwMAAAAAAAAAAAAAAA//tQxAADB8AhSmAhIIEVWWWU" if RailsAi.config.stub_responses
+        raise NotImplementedError, "Anthropic doesn't support speech generation. Use OpenAI or Gemini for speech generation."
+      end
+
+      def transcribe_audio!(audio:, model:, **opts)
+        return "[stubbed transcription]" if RailsAi.config.stub_responses
+        raise NotImplementedError, "Anthropic doesn't support audio transcription. Use OpenAI or Gemini for audio transcription."
+      end
+
+      # Multimodal analysis - Anthropic supports image analysis with Claude 3 Vision
+      def analyze_image!(image:, prompt:, model: "claude-3-5-sonnet-20241022", **opts)
+        return "[stubbed] Image analysis: #{prompt}" if RailsAi.config.stub_responses
+        
+        # Anthropic supports image analysis with Claude 3 Vision models
+        messages = [
+          {
+            role: "user",
+            content: [
+              {
+                type: "image",
+                source: {
+                  type: "base64",
+                  media_type: detect_image_type(image),
+                  data: extract_base64_data(image)
+                }
+              },
+              {
+                type: "text",
+                text: prompt
+              }
+            ]
+          }
+        ]
+        
+        response = make_request(
+          "messages",
+          {
+            model: model,
+            max_tokens: opts[:max_tokens] || RailsAi.config.token_limit,
+            messages: messages,
+            temperature: opts[:temperature] || 1.0,
+            top_p: opts[:top_p] || 1.0,
+            top_k: opts[:top_k] || 0,
+            **opts.except(:max_tokens, :temperature, :top_p, :top_k)
+          }
+        )
+        
+        response.dig("content", 0, "text")
+      end
+
+      def analyze_video!(video:, prompt:, model:, **opts)
+        return "[stubbed] Video analysis: #{prompt}" if RailsAi.config.stub_responses
+        raise NotImplementedError, "Anthropic doesn't support video analysis. Use OpenAI or Gemini for video analysis."
+      end
+
+      private
+
+      def make_request(endpoint, payload)
+        uri = URI("#{ANTHROPIC_API_BASE}/#{endpoint}")
+        
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        
+        request = Net::HTTP::Post.new(uri)
+        request["x-api-key"] = @api_key
+        request["Content-Type"] = "application/json"
+        request["anthropic-version"] = "2023-06-01"
+        request.body = payload.to_json
+        
+        response = http.request(request)
+        
+        if response.code == "200"
+          JSON.parse(response.body)
+        else
+          error_body = JSON.parse(response.body) rescue response.body
+          raise "Anthropic API error (#{response.code}): #{error_body}"
+        end
+      end
+
+      def make_streaming_request(endpoint, payload, &block)
+        uri = URI("#{ANTHROPIC_API_BASE}/#{endpoint}")
+        
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        
+        request = Net::HTTP::Post.new(uri)
+        request["x-api-key"] = @api_key
+        request["Content-Type"] = "application/json"
+        request["anthropic-version"] = "2023-06-01"
+        request.body = payload.to_json
+        
+        http.request(request) do |response|
+          if response.code == "200"
+            response.read_body do |chunk|
+              # Parse streaming response chunks
+              chunk.split("\n").each do |line|
+                next if line.empty?
+                next unless line.start_with?("data: ")
+                
+                data = line[6..-1] # Remove "data: " prefix
+                next if data == "[DONE]"
+                
+                begin
+                  parsed = JSON.parse(data)
+                  block.call(parsed)
+                rescue JSON::ParserError
+                  # Skip invalid JSON chunks
+                  next
+                end
+              end
+            end
+          else
+            error_body = JSON.parse(response.body) rescue response.body
+            raise "Anthropic API error (#{response.code}): #{error_body}"
+          end
+        end
+      end
+
+      def convert_messages_to_anthropic(messages)
+        messages.map do |message|
+          {
+            role: message[:role] == "assistant" ? "assistant" : "user",
+            content: message[:content]
+          }
+        end
+      end
+
+      def detect_image_type(image)
+        if image.is_a?(String)
+          if image.start_with?("data:image/")
+            image.split(";")[0].split(":")[1]
+          else
+            "image/png" # default
+          end
+        else
+          "image/png" # default for file objects
+        end
+      end
+
+      def extract_base64_data(image)
+        if image.is_a?(String) && image.include?("base64,")
+          image.split("base64,")[1]
+        else
+          # For file objects, read and encode
+          Base64.strict_encode64(image.read)
+        end
+      end
+    end
+  end
+end

data/lib/rails_ai/providers/base.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RailsAi
+  module Providers
+    class Base
+      # Text-based AI operations
+      def chat!(messages:, model:, **opts)
+        raise NotImplementedError
+      end
+
+      def stream_chat!(messages:, model:, **opts, &on_token)
+        raise NotImplementedError
+      end
+
+      def embed!(texts:, model:, **opts)
+        raise NotImplementedError
+      end
+
+      # Image generation
+      def generate_image!(prompt:, model: "dall-e-3", size: "1024x1024", quality: "standard", **opts)
+        raise NotImplementedError
+      end
+
+      def edit_image!(image:, prompt:, mask: nil, size: "1024x1024", **opts)
+        raise NotImplementedError
+      end
+
+      def create_variation!(image:, size: "1024x1024", **opts)
+        raise NotImplementedError
+      end
+
+      # Video generation
+      def generate_video!(prompt:, model: "sora", duration: 5, **opts)
+        raise NotImplementedError
+      end
+
+      def edit_video!(video:, prompt:, **opts)
+        raise NotImplementedError
+      end
+
+      # Audio generation
+      def generate_speech!(text:, model: "tts-1", voice: "alloy", **opts)
+        raise NotImplementedError
+      end
+
+      def transcribe_audio!(audio:, model: "whisper-1", **opts)
+        raise NotImplementedError
+      end
+
+      # Multimodal operations
+      def analyze_image!(image:, prompt:, model: "gpt-4-vision-preview", **opts)
+        raise NotImplementedError
+      end
+
+      def analyze_video!(video:, prompt:, model: "gpt-4-vision-preview", **opts)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/rails_ai/providers/dummy_adapter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RailsAi
+  module Providers
+    class DummyAdapter < Base
+      # Text-based operations
+      def chat!(messages:, model:, **opts) = "[dummy] #{messages.last[:content].to_s.reverse}"
+      def stream_chat!(messages:, model:, **opts, &on_token) = messages.last[:content].chars.each { |c| on_token.call(c) }
+      def embed!(texts:, model:, **opts) = texts.map { |t| [t.length.to_f] }
+
+      # Image generation
+      def generate_image!(prompt:, model:, **opts) = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
+      def edit_image!(image:, prompt:, **opts) = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
+      def create_variation!(image:, **opts) = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNkYPhfDwAChwGA60e6kgAAAABJRU5ErkJggg=="
+
+      # Video generation
+      def generate_video!(prompt:, model:, **opts) = "data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAAAB1tZGF0AQAAARxtYXNrAAAAAG1wNDEAAAAAIG1kYXQ="
+      def edit_video!(video:, prompt:, **opts) = "data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAAAB1tZGF0AQAAARxtYXNrAAAAAG1wNDEAAAAAIG1kYXQ="
+
+      # Audio generation
+      def generate_speech!(text:, model:, **opts) = "data:audio/mp3;base64,SUQzBAAAAAAAI1RTU0UAAAAPAAADTGF2ZjU4Ljc2LjEwMAAAAAAAAAAAAAAA//tQxAADB8AhSmAhIIEVWWWU"
+      def transcribe_audio!(audio:, model:, **opts) = "[dummy transcription] #{audio.class.name}"
+
+      # Multimodal analysis
+      def analyze_image!(image:, prompt:, model:, **opts) = "[dummy] Image analysis: #{prompt}"
+      def analyze_video!(video:, prompt:, model:, **opts) = "[dummy] Video analysis: #{prompt}"
+    end
+  end
+end