llm_chain 0.4.0 → 0.5.1

data/lib/llm_chain/tools/code_interpreter.rb

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