llm_chain 0.3.0 → 0.5.0

data/lib/llm_chain/tools/base_tool.rb

@@ -0,0 +1,81 @@
+module LLMChain
+  module Tools
+    class BaseTool
+      attr_reader :name, :description, :parameters
+
+      def initialize(name:, description:, parameters: {})
+        @name = name
+        @description = description
+        @parameters = parameters
+      end
+
+      # Проверяет, подходит ли инструмент для данного промпта
+      # @param prompt [String] Входной промпт от пользователя
+      # @return [Boolean] true если инструмент должен быть вызван
+      def match?(prompt)
+        raise NotImplementedError, "Subclasses must implement #match?"
+      end
+
+      # Выполняет инструмент
+      # @param prompt [String] Входной промпт от пользователя
+      # @param context [Hash] Дополнительный контекст
+      # @return [String, Hash] Результат выполнения инструмента
+      def call(prompt, context: {})
+        raise NotImplementedError, "Subclasses must implement #call"
+      end
+
+      # Возвращает JSON-схему для LLM
+      def to_schema
+        {
+          name: @name,
+          description: @description,
+          parameters: {
+            type: "object",
+            properties: @parameters,
+            required: required_parameters
+          }
+        }
+      end
+
+      # Извлекает параметры из промпта (для автоматического парсинга)
+      # @param prompt [String] Входной промпт
+      # @return [Hash] Извлеченные параметры
+      def extract_parameters(prompt)
+        {}
+      end
+
+      # Форматирует результат для включения в промпт
+      # @param result [Object] Результат выполнения инструмента
+      # @return [String] Форматированный результат
+      def format_result(result)
+        case result
+        when String then result
+        when Hash, Array then JSON.pretty_generate(result)
+        else result.to_s
+        end
+      end
+
+      protected
+
+      # Список обязательных параметров
+      def required_parameters
+        []
+      end
+
+      # Помощник для проверки ключевых слов в промпте
+      def contains_keywords?(prompt, keywords)
+        keywords.any? { |keyword| prompt.downcase.include?(keyword.downcase) }
+      end
+
+      # Помощник для извлечения числовых значений
+      def extract_numbers(text)
+        text.scan(/-?\d+\.?\d*/).map(&:to_f)
+      end
+
+      # Помощник для извлечения URL
+      def extract_urls(text)
+        text.scan(%r{https?://[^\s]+})
+      end
+    end
+  end
+end 

data/lib/llm_chain/tools/calculator.rb

@@ -0,0 +1,143 @@
+require 'bigdecimal'
+
+module LLMChain
+  module Tools
+    class Calculator < BaseTool
+      KEYWORDS = %w[
+        calculate compute math equation formula
+        add subtract multiply divide
+        sum difference product quotient
+        plus minus times divided
+        + - * / = equals
+      ].freeze
+
+      def initialize
+        super(
+          name: "calculator",
+          description: "Performs mathematical calculations and evaluates expressions",
+          parameters: {
+            expression: {
+              type: "string",
+              description: "Mathematical expression to evaluate (e.g., '2 + 2', '15 * 3.14', 'sqrt(16)')"
+            }
+          }
+        )
+      end
+
+      def match?(prompt)
+        contains_keywords?(prompt, KEYWORDS) || 
+        contains_math_pattern?(prompt)
+      end
+
+      def call(prompt, context: {})
+        expression = extract_expression(prompt)
+        return "No mathematical expression found" if expression.empty?
+
+        begin
+          result = evaluate_expression(expression)
+          {
+            expression: expression,
+            result: result,
+            formatted: "#{expression} = #{result}"
+          }
+        rescue => e
+          {
+            expression: expression,
+            error: e.message,
+            formatted: "Error calculating '#{expression}': #{e.message}"
+          }
+        end
+      end
+
+      def extract_parameters(prompt)
+        { expression: extract_expression(prompt) }
+      end
+
+      private
+
+      def contains_math_pattern?(prompt)
+        # Проверяем наличие математических операторов и чисел
+        prompt.match?(/\d+\s*[+\-*\/]\s*\d+/) ||
+        prompt.match?(/\b(sqrt|sin|cos|tan|log|ln|exp|abs|round|ceil|floor)\s*\(/i)
+      end
+
+      def extract_expression(prompt)
+        # Пробуем найти выражение в кавычках
+        quoted = prompt.match(/"([^"]+)"/) || prompt.match(/'([^']+)'/)
+        return quoted[1] if quoted
+
+        # Ищем выражение после ключевых слов
+        KEYWORDS.each do |keyword|
+          if prompt.downcase.include?(keyword)
+            escaped_keyword = Regexp.escape(keyword)
+            after_keyword = prompt.split(/#{escaped_keyword}/i, 2)[1]
+            if after_keyword
+              # Извлекаем математическое выражение
+              expr = after_keyword.strip.split(/[.!?]/).first
+              return clean_expression(expr) if expr
+            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
+      end
+
+      def evaluate_expression(expression)
+        # Заменяем математические функции на Ruby-методы
+        expr = expression.downcase
+                        .gsub(/sqrt\s*\(([^)]+)\)/) { "Math.sqrt(#{$1})" }
+                        .gsub(/sin\s*\(([^)]+)\)/) { "Math.sin(#{$1})" }
+                        .gsub(/cos\s*\(([^)]+)\)/) { "Math.cos(#{$1})" }
+                        .gsub(/tan\s*\(([^)]+)\)/) { "Math.tan(#{$1})" }
+                        .gsub(/log\s*\(([^)]+)\)/) { "Math.log10(#{$1})" }
+                        .gsub(/ln\s*\(([^)]+)\)/) { "Math.log(#{$1})" }
+                        .gsub(/exp\s*\(([^)]+)\)/) { "Math.exp(#{$1})" }
+                        .gsub(/abs\s*\(([^)]+)\)/) { "(#{$1}).abs" }
+                        .gsub(/round\s*\(([^)]+)\)/) { "(#{$1}).round" }
+                        .gsub(/ceil\s*\(([^)]+)\)/) { "(#{$1}).ceil" }
+                        .gsub(/floor\s*\(([^)]+)\)/) { "(#{$1}).floor" }
+
+        # Безопасная оценка выражения
+        result = safe_eval(expr)
+        
+        # Округляем результат до разумного количества знаков
+        if result.is_a?(Float)
+          result.round(10)
+        else
+          result
+        end
+      end
+
+      def safe_eval(expression)
+        # Проверяем, что выражение содержит только безопасные символы
+        unless expression.match?(/\A[\d+\-*\/().\s]+\z/) || 
+               expression.include?('Math.') || 
+               expression.match?(/\.(abs|round|ceil|floor)\b/)
+          raise "Unsafe expression: #{expression}"
+        end
+
+        # Оцениваем выражение
+        eval(expression)
+      end
+
+      def required_parameters
+        ['expression']
+      end
+    end
+  end
+end 

data/lib/llm_chain/tools/code_interpreter.rb

@@ -0,0 +1,233 @@
+require 'tempfile'
+require 'timeout'
+
+module LLMChain
+  module Tools
+    class CodeInterpreter < BaseTool
+      KEYWORDS = %w[
+        code run execute script program
+        ruby python javascript
+        calculate compute
+        def class function
+      ].freeze
+
+      SUPPORTED_LANGUAGES = %w[ruby python javascript].freeze
+      
+      DANGEROUS_PATTERNS = [
+        /system\s*\(/i,
+        /exec\s*\(/i, 
+        /`[^`]*`/,
+        /File\.(delete|rm|unlink)/i,
+        /Dir\.(delete|rmdir)/i,
+        /require\s+['"]net\/http['"]/i,
+        /require\s+['"]open-uri['"]/i,
+        /eval\s*\(/i,
+        /instance_eval/i,
+        /class_eval/i
+      ].freeze
+
+      def initialize(timeout: 30, allowed_languages: SUPPORTED_LANGUAGES)
+        @timeout = timeout
+        @allowed_languages = allowed_languages
+        
+        super(
+          name: "code_interpreter",
+          description: "Executes code safely in an isolated environment",
+          parameters: {
+            code: {
+              type: "string",
+              description: "Code to execute"
+            },
+            language: {
+              type: "string", 
+              description: "Programming language (ruby, python, javascript)",
+              enum: @allowed_languages
+            }
+          }
+        )
+      end
+
+      def match?(prompt)
+        contains_keywords?(prompt, KEYWORDS) ||
+        contains_code_blocks?(prompt) ||
+        contains_function_definitions?(prompt)
+      end
+
+      def call(prompt, context: {})
+        code = extract_code(prompt)
+        language = detect_language(code, prompt)
+        
+        return "No code found to execute" if code.empty?
+        return "Unsupported language: #{language}" unless @allowed_languages.include?(language)
+        
+        begin
+          if safe_to_execute?(code)
+            result = execute_code(code, language)
+            {
+              code: code,
+              language: language,
+              result: result,
+              formatted: format_execution_result(code, language, result)
+            }
+          else
+            {
+              code: code,
+              language: language,
+              error: "Code contains potentially dangerous operations",
+              formatted: "Cannot execute: Code contains potentially dangerous operations"
+            }
+          end
+        rescue => e
+          {
+            code: code,
+            language: language,
+            error: e.message,
+            formatted: "Execution error: #{e.message}"
+          }
+        end
+      end
+
+      def extract_parameters(prompt)
+        code = extract_code(prompt)
+        {
+          code: code,
+          language: detect_language(code, prompt)
+        }
+      end
+
+      private
+
+      def contains_code_blocks?(prompt)
+        prompt.include?('```') || 
+        prompt.match?(/^\s*def\s+\w+/m) ||
+        prompt.match?(/^\s*class\s+\w+/m)
+      end
+
+      def contains_function_definitions?(prompt)
+        prompt.match?(/\b(def|function|class)\s+\w+/i)
+      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
+
+        # Ищем код после ключевых слов
+        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?
+            end
+          end
+        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)
+        end
+
+        code_lines.join("\n")
+      end
+
+      def detect_language(code, prompt)
+        # Явное указание языка
+        return 'ruby' if prompt.match?(/```ruby/i) || prompt.include?('Ruby')
+        return 'python' if prompt.match?(/```python/i) || prompt.include?('Python')
+        return 'javascript' if prompt.match?(/```(javascript|js)/i) || prompt.include?('JavaScript')
+
+        # Определение по синтаксису
+        return 'ruby' if code.include?('puts') || code.include?('def ') || code.match?(/\bend\b/)
+        return 'python' if code.include?('print(') || code.match?(/def \w+\(.*\):/) || code.include?('import ')
+        return 'javascript' if code.include?('console.log') || code.include?('function ') || code.include?('var ') || code.include?('let ')
+
+        'ruby' # default
+      end
+
+      def safe_to_execute?(code)
+        DANGEROUS_PATTERNS.none? { |pattern| code.match?(pattern) }
+      end
+
+      def execute_code(code, language)
+        case language
+        when 'ruby'
+          execute_ruby(code)
+        when 'python'
+          execute_python(code)
+        when 'javascript'
+          execute_javascript(code)
+        else
+          raise "Unsupported language: #{language}"
+        end
+      end
+
+      def execute_ruby(code)
+        Timeout.timeout(@timeout) do
+          # Создаем временный файл
+          Tempfile.create(['code', '.rb']) do |file|
+            file.write(code)
+            file.flush
+            
+            # Выполняем код в отдельном процессе
+            result = `ruby #{file.path} 2>&1`
+            
+            if $?.success?
+              result.strip
+            else
+              raise "Ruby execution failed: #{result}"
+            end
+          end
+        end
+      end
+
+      def execute_python(code)
+        Timeout.timeout(@timeout) do
+          Tempfile.create(['code', '.py']) do |file|
+            file.write(code)
+            file.flush
+            
+            result = `python3 #{file.path} 2>&1`
+            
+            if $?.success?
+              result.strip
+            else
+              raise "Python execution failed: #{result}"
+            end
+          end
+        end
+      end
+
+      def execute_javascript(code)
+        Timeout.timeout(@timeout) do
+          Tempfile.create(['code', '.js']) do |file|
+            file.write(code)
+            file.flush
+            
+            # Пробуем node.js
+            result = `node #{file.path} 2>&1`
+            
+            if $?.success?
+              result.strip
+            else
+              raise "JavaScript execution failed: #{result}"
+            end
+          end
+        end
+      end
+
+      def format_execution_result(code, language, result)
+        "Code execution (#{language}):\n\n```#{language}\n#{code}\n```\n\nOutput:\n```\n#{result}\n```"
+      end
+
+      def required_parameters
+        ['code']
+      end
+    end
+  end
+end 

data/lib/llm_chain/tools/tool_manager.rb

@@ -0,0 +1,204 @@
+module LLMChain
+  module Tools
+    class ToolManager
+      attr_reader :tools
+
+      def initialize(tools: [])
+        @tools = {}
+        tools.each { |tool| register_tool(tool) }
+      end
+
+      # Регистрирует новый инструмент
+      def register_tool(tool)
+        unless tool.is_a?(BaseTool)
+          raise ArgumentError, "Tool must inherit from BaseTool"
+        end
+        @tools[tool.name] = tool
+      end
+
+      # Удаляет инструмент
+      def unregister_tool(name)
+        @tools.delete(name.to_s)
+      end
+
+      # Получает инструмент по имени
+      def get_tool(name)
+        @tools[name.to_s]
+      end
+
+      # Возвращает список всех инструментов
+      def list_tools
+        @tools.values
+      end
+
+      # Получает схемы всех инструментов для LLM
+      def get_tools_schema
+        @tools.values.map(&:to_schema)
+      end
+
+      # Находит подходящие инструменты для промпта
+      def find_matching_tools(prompt)
+        @tools.values.select { |tool| tool.match?(prompt) }
+      end
+
+      # Выполняет все подходящие инструменты
+      def execute_tools(prompt, context: {})
+        matching_tools = find_matching_tools(prompt)
+        
+        results = {}
+        matching_tools.each do |tool|
+          begin
+            result = tool.call(prompt, context: context)
+            results[tool.name] = {
+              success: true,
+              result: result,
+              formatted: tool.format_result(result)
+            }
+          rescue => e
+            results[tool.name] = {
+              success: false,
+              error: e.message,
+              formatted: "Error in #{tool.name}: #{e.message}"
+            }
+          end
+        end
+
+        results
+      end
+
+      # Выполняет конкретный инструмент по имени
+      def execute_tool(name, prompt, context: {})
+        tool = get_tool(name)
+        raise ArgumentError, "Tool '#{name}' not found" unless tool
+
+        begin
+          result = tool.call(prompt, context: context)
+          {
+            success: true,
+            result: result,
+            formatted: tool.format_result(result)
+          }
+        rescue => e
+          {
+            success: false,
+            error: e.message,
+            formatted: "Error in #{name}: #{e.message}"
+          }
+        end
+      end
+
+      # Создает стандартный набор инструментов
+      def self.create_default_toolset
+        tools = [
+          Calculator.new,
+          WebSearch.new,
+          CodeInterpreter.new
+        ]
+        
+        new(tools: tools)
+      end
+
+      # Создает набор инструментов из конфигурации
+      def self.from_config(config)
+        tools = []
+        
+        config.each do |tool_config|
+          tool_class = tool_config[:class] || tool_config['class']
+          tool_options = tool_config[:options] || tool_config['options'] || {}
+          
+          case tool_class.to_s.downcase
+          when 'calculator'
+            tools << Calculator.new
+          when 'web_search', 'websearch'
+            tools << WebSearch.new(**tool_options)
+          when 'code_interpreter', 'codeinterpreter'
+            tools << CodeInterpreter.new(**tool_options)
+          else
+            raise ArgumentError, "Unknown tool class: #{tool_class}"
+          end
+        end
+        
+        new(tools: tools)
+      end
+
+      # Форматирует результаты выполнения для включения в промпт
+      def format_tool_results(results)
+        return "" if results.empty?
+
+        formatted_results = results.map do |tool_name, result|
+          "#{tool_name}: #{result[:formatted]}"
+        end
+
+        "Tool Results:\n#{formatted_results.join("\n\n")}"
+      end
+
+      # Получает краткое описание доступных инструментов
+      def tools_description
+        descriptions = @tools.values.map do |tool|
+          "- #{tool.name}: #{tool.description}"
+        end
+
+        "Available tools:\n#{descriptions.join("\n")}"
+      end
+
+      # Проверяет, содержит ли промпт запрос на использование инструментов
+      def needs_tools?(prompt)
+        # Проверяем явные запросы на использование инструментов
+        return true if prompt.match?(/\b(use tool|call tool|execute|calculate|search|run code)\b/i)
+        
+        # Проверяем, есть ли подходящие инструменты
+        find_matching_tools(prompt).any?
+      end
+
+      # Автоматически решает, какие инструменты использовать
+      def auto_execute(prompt, context: {})
+        return {} unless needs_tools?(prompt)
+        
+        # Ограничиваем количество одновременно выполняемых инструментов
+        matching_tools = find_matching_tools(prompt)
+        selected_tools = select_best_tools(matching_tools, prompt)
+        
+        results = {}
+        selected_tools.each do |tool|
+          begin
+            result = tool.call(prompt, context: context)
+            results[tool.name] = {
+              success: true,
+              result: result,
+              formatted: tool.format_result(result)
+            }
+          rescue => e
+            results[tool.name] = {
+              success: false,
+              error: e.message,
+              formatted: "Error in #{tool.name}: #{e.message}"
+            }
+          end
+        end
+
+        results
+      end
+
+      private
+
+      # Выбирает лучшие инструменты для выполнения (ограничение по количеству)
+      def select_best_tools(tools, prompt, limit: 3)
+        # Простая логика приоритизации
+        prioritized = tools.sort_by do |tool|
+          case tool.name
+          when 'calculator'
+            prompt.include?('calculate') || prompt.match?(/\d+\s*[+\-*\/]\s*\d+/) ? 0 : 2
+          when 'web_search'
+            prompt.include?('search') || prompt.match?(/\b(what|who|where|when)\b/i) ? 0 : 2
+          when 'code_interpreter'
+            prompt.include?('```') || prompt.include?('code') ? 0 : 2
+          else
+            1
+          end
+        end
+
+        prioritized.first(limit)
+      end
+    end
+  end
+end