llm_chain 0.5.0 → 0.5.2

data/lib/llm_chain/configuration_validator.rb

@@ -0,0 +1,349 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+module LLMChain
+  class ConfigurationValidator
+    class ValidationError < Error; end
+    class ValidationWarning < StandardError; end
+
+    def self.validate_chain_config!(model: nil, **options)
+      new.validate_chain_config!(model: model, **options)
+    end
+
+    def validate_chain_config!(model: nil, **options)
+      @warnings = []
+      
+      begin
+        validate_model!(model) if model
+        validate_client_availability!(model) if model
+        validate_tools!(options[:tools]) if options[:tools]
+        validate_memory!(options[:memory]) if options[:memory]
+        validate_retriever!(options[:retriever]) if options[:retriever]
+        
+        # Выводим предупреждения, если есть
+        @warnings.each { |warning| warn_user(warning) } if @warnings.any?
+        
+        true
+      rescue => e
+        raise ValidationError, "Configuration validation failed: #{e.message}"
+      end
+    end
+
+    def self.validate_environment
+      new.validate_environment
+    end
+
+    def validate_environment
+      @warnings = []
+      results = {}
+      
+      results[:ollama] = check_ollama_availability
+      results[:ruby] = check_ruby_version
+      results[:python] = check_python_availability
+      results[:node] = check_node_availability
+      results[:internet] = check_internet_connectivity
+      results[:apis] = check_api_keys
+      
+      results[:warnings] = @warnings
+      results
+    end
+
+    private
+
+    def validate_model!(model)
+      return if model.nil?
+      
+      case model.to_s
+      when /^gpt/
+        validate_openai_requirements!(model)
+      when /qwen|llama|gemma/
+        validate_ollama_requirements!(model)
+      else
+        add_warning("Unknown model type: #{model}. Proceeding with default settings.")
+      end
+    end
+
+    def validate_openai_requirements!(model)
+      api_key = ENV['OPENAI_API_KEY']
+      unless api_key
+        raise ValidationError, "OpenAI API key required for model '#{model}'. Set OPENAI_API_KEY environment variable."
+      end
+      
+      if api_key.length < 20
+        raise ValidationError, "OpenAI API key appears to be invalid (too short)."
+      end
+      
+      # Проверяем доступность OpenAI API
+      begin
+        uri = URI('https://api.openai.com/v1/models')
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.open_timeout = 5
+        http.read_timeout = 5
+        
+        request = Net::HTTP::Get.new(uri)
+        request['Authorization'] = "Bearer #{api_key}"
+        
+        response = http.request(request)
+        
+        case response.code
+        when '200'
+          # OK
+        when '401'
+          raise ValidationError, "OpenAI API key is invalid or expired."
+        when '429'
+          add_warning("OpenAI API rate limit reached. Service may be temporarily unavailable.")
+        else
+          add_warning("OpenAI API returned status #{response.code}. Service may be temporarily unavailable.")
+        end
+      rescue => e
+        add_warning("Cannot verify OpenAI API availability: #{e.message}")
+      end
+    end
+
+    def validate_ollama_requirements!(model)
+      unless check_ollama_availability
+        raise ValidationError, "Ollama is not running. Please start Ollama server with: ollama serve"
+      end
+      
+      unless model_available_in_ollama?(model)
+        raise ValidationError, "Model '#{model}' not found in Ollama. Available models: #{list_ollama_models.join(', ')}"
+      end
+    end
+
+    def validate_client_availability!(model)
+      case model.to_s
+      when /qwen|llama|gemma/
+        unless check_ollama_availability
+          raise ValidationError, "Ollama server is not running for model '#{model}'"
+        end
+      end
+    end
+
+    def validate_tools!(tools)
+      return unless tools
+      
+      if tools.respond_to?(:tools) # ToolManager
+        tools.tools.each { |tool| validate_single_tool!(tool) }
+      elsif tools.is_a?(Array)
+        tools.each { |tool| validate_single_tool!(tool) }
+      else
+        validate_single_tool!(tools)
+      end
+    end
+
+    def validate_single_tool!(tool)
+      case tool.class.name
+      when /WebSearch/
+        validate_web_search_tool!(tool)
+      when /CodeInterpreter/
+        validate_code_interpreter_tool!(tool)
+      when /Calculator/
+        # Calculator не требует дополнительной валидации
+      end
+    end
+
+    def validate_web_search_tool!(tool)
+      # Проверяем доступность Google Search API
+      if ENV['GOOGLE_API_KEY'] && ENV['GOOGLE_SEARCH_ENGINE_ID']
+        # Есть API ключи, но проверим их валидность
+        begin
+          # Простая проверка доступности
+          uri = URI('https://www.googleapis.com/customsearch/v1')
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.open_timeout = 3
+          http.read_timeout = 3
+          
+          response = http.get('/')
+          # Если получили любой ответ, значит API доступен
+        rescue => e
+          add_warning("Google Search API may be unavailable: #{e.message}")
+        end
+      else
+        add_warning("Google Search API not configured. Search will use fallback methods.")
+      end
+      
+      # Проверяем доступность интернета для fallback поиска
+      unless check_internet_connectivity
+        add_warning("No internet connection detected. Search functionality will be limited.")
+      end
+    end
+
+    def validate_code_interpreter_tool!(tool)
+      # Проверяем доступность языков программирования
+      languages = tool.instance_variable_get(:@allowed_languages) || ['ruby']
+      
+      languages.each do |lang|
+        case lang
+        when 'ruby'
+          unless check_ruby_version
+            add_warning("Ruby interpreter not found or outdated.")
+          end
+        when 'python'
+          unless check_python_availability
+            add_warning("Python interpreter not found.")
+          end
+        when 'javascript'
+          unless check_node_availability
+            add_warning("Node.js interpreter not found.")
+          end
+        end
+      end
+    end
+
+    def validate_memory!(memory)
+      return unless memory
+      
+      case memory.class.name
+      when /Redis/
+        validate_redis_memory!(memory)
+      when /Array/
+        # Array memory не требует дополнительной валидации
+      end
+    end
+
+    def validate_redis_memory!(memory)
+      begin
+        # Проверяем подключение к Redis
+        redis_client = memory.instance_variable_get(:@redis) || memory.redis
+        if redis_client.respond_to?(:ping)
+          redis_client.ping
+        end
+      rescue => e
+        raise ValidationError, "Redis connection failed: #{e.message}"
+      end
+    end
+
+    def validate_retriever!(retriever)
+      return unless retriever
+      return if retriever == false
+      
+      case retriever.class.name
+      when /Weaviate/
+        validate_weaviate_retriever!(retriever)
+      end
+    end
+
+    def validate_weaviate_retriever!(retriever)
+      # Проверяем доступность Weaviate
+      begin
+        # Попытка подключения к Weaviate
+        uri = URI('http://localhost:8080/v1/.well-known/ready')
+        response = Net::HTTP.get_response(uri)
+        
+        unless response.code == '200'
+          raise ValidationError, "Weaviate server is not ready. Please start Weaviate."
+        end
+      rescue => e
+        raise ValidationError, "Cannot connect to Weaviate: #{e.message}"
+      end
+    end
+
+    # Вспомогательные методы для проверки системы
+
+    def check_ollama_availability
+      begin
+        uri = URI('http://localhost:11434/api/tags')
+        response = Net::HTTP.get_response(uri)
+        response.code == '200'
+      rescue
+        false
+      end
+    end
+
+    def model_available_in_ollama?(model)
+      begin
+        uri = URI('http://localhost:11434/api/tags')
+        response = Net::HTTP.get_response(uri)
+        return false unless response.code == '200'
+        
+        data = JSON.parse(response.body)
+        models = data['models'] || []
+        models.any? { |m| m['name'].include?(model.to_s.split(':').first) }
+      rescue
+        false
+      end
+    end
+
+    def list_ollama_models
+      begin
+        uri = URI('http://localhost:11434/api/tags')
+        response = Net::HTTP.get_response(uri)
+        return [] unless response.code == '200'
+        
+        data = JSON.parse(response.body)
+        models = data['models'] || []
+        models.map { |m| m['name'] }
+      rescue
+        []
+      end
+    end
+
+    def check_ruby_version
+      begin
+        version = RUBY_VERSION
+        major, minor, patch = version.split('.').map(&:to_i)
+        
+        # Требуем Ruby >= 3.1.0
+        if major > 3 || (major == 3 && minor >= 1)
+          true
+        else
+          add_warning("Ruby version #{version} detected. Minimum required: 3.1.0")
+          false
+        end
+      rescue
+        false
+      end
+    end
+
+    def check_python_availability
+      begin
+        output = `python3 --version 2>&1`
+        $?.success? && output.include?('Python')
+      rescue
+        false
+      end
+    end
+
+    def check_node_availability
+      begin
+        output = `node --version 2>&1`
+        $?.success? && output.include?('v')
+      rescue
+        false
+      end
+    end
+
+    def check_internet_connectivity
+      begin
+        require 'socket'
+        Socket.tcp("8.8.8.8", 53, connect_timeout: 3) {}
+        true
+      rescue
+        false
+      end
+    end
+
+    def check_api_keys
+      keys = {}
+      keys[:openai] = !ENV['OPENAI_API_KEY'].nil?
+      keys[:google_search] = !ENV['GOOGLE_API_KEY'].nil? && !ENV['GOOGLE_SEARCH_ENGINE_ID'].nil?
+      keys[:bing_search] = !ENV['BING_API_KEY'].nil?
+      keys
+    end
+
+    def add_warning(message)
+      @warnings << message
+    end
+
+    def warn_user(message)
+      if defined?(Rails) && Rails.logger
+        Rails.logger.warn "[LLMChain] #{message}"
+      else
+        warn "[LLMChain] Warning: #{message}"
+      end
+    end
+  end
+end 

data/lib/llm_chain/tools/calculator.rb

@@ -66,6 +66,14 @@ module LLMChain
         quoted = prompt.match(/"([^"]+)"/) || prompt.match(/'([^']+)'/)
         return quoted[1] if quoted
 
+        # Пробуем найти простое выражение в тексте сначала (более точно)
+        math_expr = prompt.match(/(\d+(?:\.\d+)?\s*[+\-*\/]\s*\d+(?:\.\d+)?(?:\s*[+\-*\/]\s*\d+(?:\.\d+)?)*)/)
+        return math_expr[1].strip if math_expr
+
+        # Ищем функции
+        func_expr = prompt.match(/\b(sqrt|sin|cos|tan|log|ln|exp|abs|round|ceil|floor)\s*\([^)]+\)/i)
+        return func_expr[0] if func_expr
+
         # Ищем выражение после ключевых слов
         KEYWORDS.each do |keyword|
           if prompt.downcase.include?(keyword)
@@ -74,27 +82,30 @@ module LLMChain
             if after_keyword
               # Извлекаем математическое выражение
               expr = after_keyword.strip.split(/[.!?]/).first
-              return clean_expression(expr) if expr
+              if expr
+                cleaned = clean_expression(expr)
+                return cleaned unless cleaned.empty?
+              end
             end
           end
         end
 
-        # Пробуем найти простое выражение в тексте
-        math_expr = prompt.match(/(\d+(?:\.\d+)?\s*[+\-*\/]\s*\d+(?:\.\d+)?(?:\s*[+\-*\/]\s*\d+(?:\.\d+)?)*)/)
-        return math_expr[1] if math_expr
-
-        # Ищем функции
-        func_expr = prompt.match(/\b(sqrt|sin|cos|tan|log|ln|exp|abs|round|ceil|floor)\s*\([^)]+\)/i)
-        return func_expr[0] if func_expr
-
         ""
       end
 
       def clean_expression(expr)
-        # Удаляем лишние слова и оставляем только математическое выражение
-        expr.gsub(/\b(is|what|equals?|result|answer)\b/i, '')
-            .gsub(/[^\d+\-*\/().\s]/, '')
-            .strip
+        # Удаляем лишние слова но оставляем числа и операторы
+        cleaned = expr.gsub(/\b(is|what|equals?|result|answer|the)\b/i, '')
+                     .gsub(/[^\d+\-*\/().\s]/, ' ')  # заменяем на пробелы, не удаляем
+                     .gsub(/\s+/, ' ')  # убираем множественные пробелы
+                     .strip
+        
+        # Проверяем что результат похож на математическое выражение
+        if cleaned.match?(/\d+(?:\.\d+)?\s*[+\-*\/]\s*\d+(?:\.\d+)?/)
+          cleaned
+        else
+          ""
+        end
       end
 
       def evaluate_expression(expression)

data/lib/llm_chain/tools/code_interpreter.rb

@@ -108,32 +108,192 @@ module LLMChain
       end
 
       def extract_code(prompt)
-        # Ищем код в блоках ```
-        code_block = prompt.match(/```(?:ruby|python|javascript|js)?\s*\n(.*?)\n```/m)
-        return code_block[1].strip if code_block
+        # Нормализуем line endings
+        normalized_prompt = normalize_line_endings(prompt)
+        
+        # 1. Пробуем различные паттерны markdown блоков
+        code = extract_markdown_code_blocks(normalized_prompt)
+        return clean_code(code) if code && !code.empty?
+
+        # 2. Ищем код после ключевых команд в одной строке
+        code = extract_inline_code_commands(normalized_prompt)
+        return clean_code(code) if code && !code.empty?
+
+        # 3. Ищем код после ключевых слов в разных строках
+        code = extract_multiline_code_blocks(normalized_prompt)
+        return clean_code(code) if code && !code.empty?
+
+        # 4. Ищем строки, которые выглядят как код
+        code = extract_code_like_lines(normalized_prompt)
+        return clean_code(code) if code && !code.empty?
+
+        # 5. Последняя попытка - весь текст после первого кода
+        code = extract_fallback_code(normalized_prompt)
+        clean_code(code)
+      end
 
-        # Ищем код после ключевых слов
+      private
+
+      def normalize_line_endings(text)
+        text.gsub(/\r\n/, "\n").gsub(/\r/, "\n")
+      end
+
+      def extract_markdown_code_blocks(prompt)
+        # Различные паттерны для markdown блоков
+        patterns = [
+          # Стандартный markdown с указанием языка
+          /```(?:ruby|python|javascript|js)\s*\n(.*?)\n```/mi,
+          # Markdown без указания языка
+          /```\s*\n(.*?)\n```/mi,
+          # Markdown с любым языком
+          /```\w*\s*\n(.*?)\n```/mi,
+          # Тильды вместо backticks
+          /~~~(?:ruby|python|javascript|js)?\s*\n(.*?)\n~~~/mi,
+          # Без переносов строк
+          /```(?:ruby|python|javascript|js)?(.*?)```/mi,
+          # Четыре пробела (indented code blocks)
+          /^    (.+)$/m
+        ]
+        
+        patterns.each do |pattern|
+          match = prompt.match(pattern)
+          return match[1] if match && match[1].strip.length > 0
+        end
+        
+        nil
+      end
+
+      def extract_inline_code_commands(prompt)
+        # Команды в одной строке
+        inline_patterns = [
+          /execute\s+code:\s*(.+)/i,
+          /run\s+code:\s*(.+)/i,
+          /run\s+this:\s*(.+)/i,
+          /execute:\s*(.+)/i,
+          /run:\s*(.+)/i,
+          /code:\s*(.+)/i
+        ]
+        
+        inline_patterns.each do |pattern|
+          match = prompt.match(pattern)
+          return match[1] if match && match[1].strip.length > 0
+        end
+        
+        nil
+      end
+
+      def extract_multiline_code_blocks(prompt)
+        lines = prompt.split("\n")
+        
         KEYWORDS.each do |keyword|
-          if prompt.downcase.include?(keyword)
-            lines = prompt.split("\n")
-            keyword_line = lines.find_index { |line| line.downcase.include?(keyword) }
-            if keyword_line
-              # Берем строки после ключевого слова
-              code_lines = lines[(keyword_line + 1)..-1]
-              code = code_lines&.join("\n")&.strip
-              return code if code && !code.empty?
+          keyword_line_index = lines.find_index { |line| line.downcase.include?(keyword.downcase) }
+          next unless keyword_line_index
+          
+          # Берем строки после ключевого слова
+          code_lines = lines[(keyword_line_index + 1)..-1]
+          next unless code_lines
+          
+          # Найдем первую непустую строку
+          first_code_line = code_lines.find_index { |line| !line.strip.empty? }
+          next unless first_code_line
+          
+          # Берем все строки начиная с первой непустой
+          relevant_lines = code_lines[first_code_line..-1]
+          
+          # Определяем отступ первой строки кода
+          first_line = relevant_lines.first
+          indent = first_line.match(/^(\s*)/)[1].length
+          
+          # Собираем все строки с таким же или большим отступом
+          code_block = []
+          relevant_lines.each do |line|
+            if line.strip.empty?
+              code_block << "" # Сохраняем пустые строки
+            elsif line.match(/^(\s*)/)[1].length >= indent
+              code_block << line
+            else
+              break # Прекращаем при уменьшении отступа
             end
           end
+          
+          return code_block.join("\n") if code_block.any? { |line| !line.strip.empty? }
         end
+        
+        nil
+      end
 
-        # Ищем строки, которые выглядят как код
-        code_lines = prompt.split("\n").select do |line|
-          line.strip.match?(/^(def|class|function|var|let|const|print|puts|console\.log)/i) ||
-          line.strip.match?(/^\w+\s*[=+\-*\/]\s*/) ||
-          line.strip.match?(/^\s*(if|for|while|return)[\s(]/i)
+      def extract_code_like_lines(prompt)
+        lines = prompt.split("\n")
+        
+        code_lines = lines.select do |line|
+          stripped = line.strip
+          next false if stripped.empty?
+          
+          # Проверяем различные паттерны кода
+          stripped.match?(/^(def|class|function|var|let|const|print|puts|console\.log)/i) ||
+          stripped.match?(/^\w+\s*[=+\-*\/]\s*/) ||
+          stripped.match?(/^\s*(if|for|while|return|import|require)[\s(]/i) ||
+          stripped.match?(/puts\s+/) ||
+          stripped.match?(/print\s*\(/) ||
+          stripped.match?(/^\w+\(.*\)/) ||
+          stripped.match?(/^\s*#.*/) ||  # Комментарии
+          stripped.match?(/^\s*\/\/.*/) || # JS комментарии
+          stripped.match?(/^\s*\/\*.*\*\//) # Блочные комментарии
         end
+        
+        code_lines.join("\n") if code_lines.any?
+      end
 
-        code_lines.join("\n")
+      def extract_fallback_code(prompt)
+        # Последняя попытка - ищем что-то похожее на код
+        lines = prompt.split("\n")
+        
+        # Найдем первую строку, которая выглядит как код
+        start_index = lines.find_index do |line|
+          stripped = line.strip
+          stripped.match?(/^(def|class|function|puts|print|console\.log|var|let|const)/i) ||
+          stripped.include?('=') ||
+          stripped.include?(';')
+        end
+        
+        return nil unless start_index
+        
+        # Берем все строки после найденной
+        code_lines = lines[start_index..-1]
+        
+        # Останавливаемся на первой строке, которая явно не код
+        end_index = code_lines.find_index do |line|
+          stripped = line.strip
+          stripped.match?(/^(что|как|где|когда|зачем|почему|what|how|where|when|why)/i) ||
+          stripped.length > 100 # Слишком длинная строка
+        end
+        
+        relevant_lines = end_index ? code_lines[0...end_index] : code_lines
+        relevant_lines.join("\n")
+      end
+
+      def clean_code(code)
+        return "" unless code
+        
+        lines = code.strip.lines
+        
+        # Удаляем только комментарии, которые не являются частью кода
+        cleaned_lines = lines.reject do |line|
+          stripped = line.strip
+          # Удаляем только строки, которые содержат ТОЛЬКО комментарии
+          stripped.match?(/^\s*#[^{]*$/) || # Ruby комментарии (но не интерполяция)
+          stripped.match?(/^\s*\/\/.*$/) || # JS комментарии
+          stripped.match?(/^\s*\/\*.*\*\/\s*$/) # Блочные комментарии
+        end
+        
+        # Убираем пустые строки в начале и конце, но сохраняем внутри
+        start_index = cleaned_lines.find_index { |line| !line.strip.empty? }
+        return "" unless start_index
+        
+        end_index = cleaned_lines.rindex { |line| !line.strip.empty? }
+        return "" unless end_index
+        
+        cleaned_lines[start_index..end_index].join
       end
 
       def detect_language(code, prompt)