llm_chain 0.5.1 → 0.5.2

data/lib/llm_chain/tools/code_interpreter.rb

@@ -108,41 +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
 
-        # Ищем код после ключевых слов в той же строке (например, "Execute code: puts ...")
-        execute_match = prompt.match(/execute\s+code:\s*(.+)/i)
-        return execute_match[1].strip if execute_match
+      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
 
-        run_match = prompt.match(/run\s+code:\s*(.+)/i)
-        return run_match[1].strip if run_match
+      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
+
+      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 = 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) ||
-          line.strip.match?(/puts\s+/) ||
-          line.strip.match?(/print\s*\(/)
+      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
 
-        code_lines.join("\n")
+      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)

data/lib/llm_chain/tools/web_search.rb

@@ -46,13 +46,15 @@ module LLMChain
         num_results = extract_num_results(prompt)
         
         begin
-          results = perform_search(query, num_results)
+          results = perform_search_with_retry(query, num_results)
           format_search_results(query, results)
         rescue => e
+          log_error("Search failed for '#{query}'", e)
           {
             query: query,
             error: e.message,
-            formatted: "Error searching for '#{query}': #{e.message}"
+            results: [],
+            formatted: "Search unavailable for '#{query}'. Please try again later or rephrase your query."
           }
         end
       end
@@ -97,6 +99,31 @@ module LLMChain
         5 # default
       end
 
+      def perform_search_with_retry(query, num_results, max_retries: 3)
+        retries = 0
+        last_error = nil
+
+        begin
+          perform_search(query, num_results)
+        rescue => e
+          last_error = e
+          retries += 1
+          
+          if retries <= max_retries && retryable_error?(e)
+            sleep_time = [0.5 * (2 ** (retries - 1)), 5.0].min # exponential backoff, max 5 seconds
+            log_retry("Retrying search (#{retries}/#{max_retries}) after #{sleep_time}s", e)
+            sleep(sleep_time)
+            retry
+          else
+            log_error("Search failed after #{retries} attempts", e)
+            # Fallback to hardcoded results as last resort
+            hardcoded = get_hardcoded_results(query)
+            return hardcoded unless hardcoded.empty?
+            raise e
+          end
+        end
+      end
+
       def perform_search(query, num_results)
         case @search_engine
         when :google
@@ -115,25 +142,52 @@ module LLMChain
       def fallback_search(query, num_results)
         return [] if num_results <= 0
         
-        # Если обычный поиск не работает, используем заранее заготовленные данные
-        # для популярных запросов
+        # Сначала пробуем заранее заготовленные данные для популярных запросов
         hardcoded_results = get_hardcoded_results(query)
         return hardcoded_results unless hardcoded_results.empty?
         
-        # Простой поиск по HTML странице DuckDuckGo
-        uri = URI("https://html.duckduckgo.com/html/")
-        uri.query = URI.encode_www_form(q: query)
-        
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-        http.open_timeout = 10
-        http.read_timeout = 10
+        # Проверяем, доступен ли интернет
+        return offline_fallback_results(query) if offline_mode?
         
-        response = http.get(uri.request_uri)
-        return [] unless response.code == '200'
+        begin
+          results = search_duckduckgo_html(query, num_results)
+          return results unless results.empty?
+          
+          # Если DuckDuckGo не дал результатов, возвращаем заглушку
+          offline_fallback_results(query)
+        rescue => e
+          log_error("Fallback search failed", e)
+          offline_fallback_results(query)
+        end
+      end
+
+      def search_duckduckgo_html(query, num_results)
+        require 'timeout'
         
-        # Улучшенный парсинг результатов
-        html = response.body
+        Timeout.timeout(15) do
+          uri = URI("https://html.duckduckgo.com/html/")
+          uri.query = URI.encode_www_form(q: query)
+          
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.open_timeout = 8
+          http.read_timeout = 10
+          
+          response = http.get(uri.request_uri)
+          
+          unless response.code == '200'
+            log_error("DuckDuckGo returned #{response.code}", StandardError.new(response.body))
+            return []
+          end
+          
+          parse_duckduckgo_results(response.body, num_results)
+        end
+      rescue Timeout::Error
+        log_error("DuckDuckGo search timeout", Timeout::Error.new("Request took longer than 15 seconds"))
+        []
+      end
+
+      def parse_duckduckgo_results(html, num_results)
         results = []
         
         # Ищем различные паттерны результатов
@@ -147,9 +201,10 @@ module LLMChain
           html.scan(pattern) do |url, title|
             next if results.length >= num_results
             next if url.include?('duckduckgo.com/y.js') # Skip tracking links
+            next if title.strip.empty?
             
             results << {
-              title: title.strip.gsub(/\s+/, ' '),
+              title: clean_html_text(title),
               url: clean_url(url),
               snippet: "Search result from DuckDuckGo"
             }
@@ -158,14 +213,37 @@ module LLMChain
         end
         
         results
-      rescue => e
+      end
+
+      def offline_fallback_results(query)
         [{
           title: "Search unavailable",
           url: "",  
-          snippet: "Unable to perform web search at this time. Query: #{query}"
+          snippet: "Unable to perform web search at this time. Query: #{query}. Please check your internet connection."
         }]
       end
 
+      def offline_mode?
+        # Простая проверка доступности интернета
+        begin
+          require 'socket'
+          Socket.tcp("8.8.8.8", 53, connect_timeout: 3) {}
+          false
+        rescue
+          true
+        end
+      end
+
+      def clean_html_text(text)
+        text.strip
+            .gsub(/&lt;/, '<')
+            .gsub(/&gt;/, '>')
+            .gsub(/&amp;/, '&')
+            .gsub(/&quot;/, '"')
+            .gsub(/&#39;/, "'")
+            .gsub(/\s+/, ' ')
+      end
+
       # Заранее заготовленные результаты для популярных запросов
       def get_hardcoded_results(query)
         ruby_version_queries = [
@@ -203,76 +281,151 @@ module LLMChain
       def search_google(query, num_results)
         # Google Custom Search API (требует API ключ)
         unless @api_key
+          log_error("Google API key not provided, using fallback", StandardError.new("No API key"))
           return fallback_search(query, num_results)
         end
 
-        search_engine_id = ENV['GOOGLE_SEARCH_ENGINE_ID'] || ENV['GOOGLE_CX'] || 'your-search-engine-id'
-        
-        uri = URI("https://www.googleapis.com/customsearch/v1")
-        params = {
-          key: @api_key,
-          cx: search_engine_id,
-          q: query,
-          num: [num_results, 10].min
-        }
-        uri.query = URI.encode_www_form(params)
-
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-        http.open_timeout = 10
-        http.read_timeout = 10
-
-        response = http.get(uri.request_uri)
-        
-        unless response.code == '200'
+        search_engine_id = ENV['GOOGLE_SEARCH_ENGINE_ID'] || ENV['GOOGLE_CX']
+        unless search_engine_id && search_engine_id != 'your-search-engine-id'
+          log_error("Google Search Engine ID not configured", StandardError.new("Missing GOOGLE_SEARCH_ENGINE_ID"))
           return fallback_search(query, num_results)
         end
-
-        data = JSON.parse(response.body)
         
-        results = (data['items'] || []).map do |item|
-          {
-            title: item['title'],
-            url: item['link'],
-            snippet: item['snippet']
-          }
+        begin
+          require 'timeout'
+          
+          Timeout.timeout(20) do
+            uri = URI("https://www.googleapis.com/customsearch/v1")
+            params = {
+              key: @api_key,
+              cx: search_engine_id,
+              q: query,
+              num: [num_results, 10].min,
+              safe: 'active'
+            }
+            uri.query = URI.encode_www_form(params)
+
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+            http.open_timeout = 8
+            http.read_timeout = 12
+
+            response = http.get(uri.request_uri)
+            
+            case response.code
+            when '200'
+              data = JSON.parse(response.body)
+              
+              if data['error']
+                log_error("Google API error: #{data['error']['message']}", StandardError.new(data['error']['message']))
+                return fallback_search(query, num_results)
+              end
+              
+              results = (data['items'] || []).map do |item|
+                {
+                  title: item['title']&.strip || 'Untitled',
+                  url: item['link'] || '',
+                  snippet: item['snippet']&.strip || 'No description available'
+                }
+              end
+              
+              # Если Google не вернул результатов, используем fallback
+              results.empty? ? fallback_search(query, num_results) : results
+            when '403'
+              log_error("Google API quota exceeded or invalid key", StandardError.new(response.body))
+              fallback_search(query, num_results)
+            when '400'
+              log_error("Google API bad request", StandardError.new(response.body))
+              fallback_search(query, num_results)
+            else
+              log_error("Google API returned #{response.code}", StandardError.new(response.body))
+              fallback_search(query, num_results)
+            end
+          end
+        rescue Timeout::Error
+          log_error("Google search timeout", Timeout::Error.new("Request took longer than 20 seconds"))
+          fallback_search(query, num_results)
+        rescue JSON::ParserError => e
+          log_error("Invalid JSON response from Google", e)
+          fallback_search(query, num_results)
+        rescue => e
+          log_error("Google search failed", e)
+          fallback_search(query, num_results)
         end
-        
-        # Если Google не вернул результатов, используем fallback
-        results.empty? ? fallback_search(query, num_results) : results
-      rescue => e
-        fallback_search(query, num_results)
       end
 
       def search_bing(query, num_results)
         # Bing Web Search API (требует API ключ)
-        raise "Bing API key required" unless @api_key
-
-        uri = URI("https://api.bing.microsoft.com/v7.0/search")
-        params = {
-          q: query,
-          count: [num_results, 20].min,
-          responseFilter: 'Webpages'
-        }
-        uri.query = URI.encode_www_form(params)
+        unless @api_key
+          log_error("Bing API key not provided, using fallback", StandardError.new("No API key"))
+          return fallback_search(query, num_results)
+        end
 
-        http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = true
-        
-        request = Net::HTTP::Get.new(uri)
-        request['Ocp-Apim-Subscription-Key'] = @api_key
-        
-        response = http.request(request)
-        raise "Bing API error: #{response.code}" unless response.code == '200'
+        begin
+          require 'timeout'
+          
+          Timeout.timeout(20) do
+            uri = URI("https://api.bing.microsoft.com/v7.0/search")
+            params = {
+              q: query,
+              count: [num_results, 20].min,
+              responseFilter: 'Webpages',
+              safeSearch: 'Moderate'
+            }
+            uri.query = URI.encode_www_form(params)
 
-        data = JSON.parse(response.body)
-        
-        (data.dig('webPages', 'value') || []).map do |item|
-          {
-            title: item['name'],
-            url: item['url'],
-            snippet: item['snippet']
-          }
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+            http.open_timeout = 8
+            http.read_timeout = 12
+            
+            request = Net::HTTP::Get.new(uri)
+            request['Ocp-Apim-Subscription-Key'] = @api_key
+            request['User-Agent'] = 'LLMChain/1.0'
+            
+            response = http.request(request)
+            
+            case response.code
+            when '200'
+              data = JSON.parse(response.body)
+              
+              if data['error']
+                log_error("Bing API error: #{data['error']['message']}", StandardError.new(data['error']['message']))
+                return fallback_search(query, num_results)
+              end
+              
+              results = (data.dig('webPages', 'value') || []).map do |item|
+                {
+                  title: item['name']&.strip || 'Untitled',
+                  url: item['url'] || '',
+                  snippet: item['snippet']&.strip || 'No description available'
+                }
+              end
+              
+              results.empty? ? fallback_search(query, num_results) : results
+            when '401'
+              log_error("Bing API unauthorized - check your subscription key", StandardError.new(response.body))
+              fallback_search(query, num_results)
+            when '403'
+              log_error("Bing API quota exceeded", StandardError.new(response.body))
+              fallback_search(query, num_results)
+            when '429'
+              log_error("Bing API rate limit exceeded", StandardError.new(response.body))
+              fallback_search(query, num_results)
+            else
+              log_error("Bing API returned #{response.code}", StandardError.new(response.body))
+              fallback_search(query, num_results)
+            end
+          end
+        rescue Timeout::Error
+          log_error("Bing search timeout", Timeout::Error.new("Request took longer than 20 seconds"))
+          fallback_search(query, num_results)
+        rescue JSON::ParserError => e
+          log_error("Invalid JSON response from Bing", e)
+          fallback_search(query, num_results)
+        rescue => e
+          log_error("Bing search failed", e)
+          fallback_search(query, num_results)
         end
       end
 
@@ -300,6 +453,52 @@ module LLMChain
       def required_parameters
         ['query']
       end
+
+      private
+
+      def retryable_error?(error)
+        # Определяем, стоит ли повторять запрос при данной ошибке
+        case error
+        when Net::TimeoutError, Net::OpenTimeout, Net::ReadTimeout
+          true
+        when SocketError
+          # DNS ошибки обычно временные
+          true
+        when Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EHOSTUNREACH
+          true
+        when Net::HTTPError
+          # Повторяем только для серверных ошибок (5xx)
+          error.message.match?(/5\d\d/)
+        else
+          false
+        end
+      end
+
+      def log_error(message, error)
+        return unless should_log?
+        
+        if defined?(Rails) && Rails.logger
+          Rails.logger.error "[WebSearch] #{message}: #{error.class} - #{error.message}"
+        else
+          warn "[WebSearch] #{message}: #{error.class} - #{error.message}"
+        end
+      end
+
+      def log_retry(message, error)
+        return unless should_log?
+        
+        if defined?(Rails) && Rails.logger
+          Rails.logger.warn "[WebSearch] #{message}: #{error.class} - #{error.message}"
+        else
+          warn "[WebSearch] #{message}: #{error.class} - #{error.message}"
+        end
+      end
+
+      def should_log?
+        ENV['LLM_CHAIN_DEBUG'] == 'true' || 
+        ENV['RAILS_ENV'] == 'development' ||
+        (defined?(Rails) && Rails.env.development?)
+      end
     end
   end
 end 

data/lib/llm_chain/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmChain
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 end