llm_chain 0.5.3 → 0.5.5

data/lib/llm_chain/tools/calculator.rb

@@ -2,7 +2,14 @@ require 'bigdecimal'
 
 module LLMChain
   module Tools
-    class Calculator < BaseTool
+    # Performs mathematical calculations and evaluates expressions.
+    # Supports basic arithmetic and common math functions (sqrt, sin, cos, etc).
+    #
+    # @example
+    #   calculator = LLMChain::Tools::Calculator.new
+    #   calculator.call('What is sqrt(16) + 2 * 3?')
+    #   # => { expression: 'sqrt(16) + 2 * 3', result: 10.0, formatted: 'sqrt(16) + 2 * 3 = 10.0' }
+    class Calculator < Base
       KEYWORDS = %w[
         calculate compute math equation formula
         add subtract multiply divide
@@ -11,6 +18,22 @@ module LLMChain
         + - * / = equals
       ].freeze
 
+      # Regex patterns for expression extraction and validation
+      FUNC_EXPR_PATTERN = /\w+\([^\)]+\)(?:\s*[+\-\*\/]\s*(?:-?\d+(?:\.\d+)?|\w+\([^\)]+\)|\([^\)]+\))*)*/.freeze
+      MATH_EXPR_PATTERN = /((?:-?\d+(?:\.\d+)?|\w+\([^\(\)]+\)|\([^\(\)]+\))\s*(?:[+\-\*\/]\s*(?:-?\d+(?:\.\d+)?|\w+\([^\(\)]+\)|\([^\(\)]+\))\s*)+)/.freeze
+      QUOTED_EXPR_PATTERN = /"([^"]+)"|'([^']+)'/.freeze
+      SIMPLE_MATH_PATTERN = /(\d+(?:\.\d+)?\s*[+\-\*\/]\s*\d+(?:\.\d+)?(?:\s*[+\-\*\/]\s*\d+(?:\.\d+)?)*)/.freeze
+      FUNC_CALL_PATTERN = /\b(sqrt|sin|cos|tan|log|ln|exp|abs|round|ceil|floor)\s*\([^\)]+\)/i.freeze
+      MATH_OPERATOR_PATTERN = /\d+\s*[+\-\*\/]\s*\d+/.freeze
+      MATH_FUNCTION_PATTERN = /\b(sqrt|sin|cos|tan|log|ln|exp|abs|round|ceil|floor)\s*\(/i.freeze
+      CLEAN_EXTRA_WORDS_PATTERN = /\b(is|what|equals?|result|answer|the)\b/i.freeze
+      CLEAN_NON_MATH_PATTERN = /[^\d+\-*\/().\s]/.freeze
+      MULTIPLE_SPACES_PATTERN = /\s+/.freeze
+      VALID_MATH_EXPRESSION_PATTERN = /\d+(?:\.\d+)?\s*[+\-\*\/]\s*\d+(?:\.\d+)?/.freeze
+      SAFE_EVAL_PATTERN = /\A[\d+\-*\/().\s]+\z/.freeze
+      SAFE_EVAL_METHOD_PATTERN = /\.(abs|round|ceil|floor)\b/.freeze
+
+      # Initializes the calculator tool.
       def initialize
         super(
           name: "calculator",
@@ -24,14 +47,21 @@ module LLMChain
         )
       end
 
+      # Checks if the prompt contains a mathematical expression or keyword.
+      # @param prompt [String]
+      # @return [Boolean]
       def match?(prompt)
         contains_keywords?(prompt, KEYWORDS) || 
         contains_math_pattern?(prompt)
       end
 
+      # Evaluates a mathematical expression found in the prompt.
+      # @param prompt [String]
+      # @param context [Hash]
+      # @return [Hash] result, expression, and formatted string; or error info
       def call(prompt, context: {})
         expression = extract_expression(prompt)
-        return "No mathematical expression found" if expression.empty?
+        return { error: "No mathematical expression found" } if expression.empty?
 
         begin
           result = evaluate_expression(expression)
@@ -49,38 +79,76 @@ module LLMChain
         end
       end
 
+      # Extracts the parameters for the tool from the prompt.
+      # @param prompt [String]
+      # @return [Hash]
       def extract_parameters(prompt)
         { expression: extract_expression(prompt) }
       end
 
       private
 
+      # Checks if the prompt contains a math pattern (numbers and operators or functions).
+      # @param prompt [String]
+      # @return [Boolean]
       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)
+        prompt.match?(MATH_OPERATOR_PATTERN) ||
+        prompt.match?(MATH_FUNCTION_PATTERN)
       end
 
+      # Extracts a mathematical expression from the prompt using multiple strategies.
+      # @param prompt [String]
+      # @return [String]
       def extract_expression(prompt)
-        # Пробуем найти выражение в кавычках
-        quoted = prompt.match(/"([^"]+)"/) || prompt.match(/'([^']+)'/)
-        return quoted[1] if quoted
+        extract_math_expression(prompt).tap { |expr| return expr unless expr.empty? }
+        extract_quoted_expression(prompt).tap { |expr| return expr unless expr.empty? }
+        extract_simple_math_expression(prompt).tap { |expr| return expr unless expr.empty? }
+        extract_function_call(prompt).tap { |expr| return expr unless expr.empty? }
+        extract_keyword_expression(prompt).tap { |expr| return expr unless expr.empty? }
+        ""
+      end
+
+      # Extracts a complex math expression (numbers, functions, operators, spaces) from the prompt.
+      def extract_math_expression(prompt)
+        # First, try to match an expression starting with a function call and any number of operator+operand pairs
+        func_expr = prompt.match(FUNC_EXPR_PATTERN)
+        if func_expr
+          expr = func_expr[0].strip.gsub(/[.?!]$/, '')
+          puts "[DEBUG_CALC] Extracted math expression (func first): '#{expr}' from prompt: '#{prompt}'" if ENV['DEBUG_CALC']
+          return expr
+        end
+        # Fallback to previous logic
+        match = prompt.match(MATH_EXPR_PATTERN)
+        expr = match ? match[1].strip.gsub(/[.?!]$/, '') : ""
+        puts "[DEBUG_CALC] Extracted math expression: '#{expr}' from prompt: '#{prompt}'" if ENV['DEBUG_CALC']
+        expr
+      end
+
+      # Extracts an expression in quotes from the prompt.
+      def extract_quoted_expression(prompt)
+        quoted = prompt.match(QUOTED_EXPR_PATTERN)
+        quoted ? (quoted[1] || quoted[2]) : ""
+      end
 
-        # Пробуем найти простое выражение в тексте сначала (более точно)
-        math_expr = prompt.match(/(\d+(?:\.\d+)?\s*[+\-*\/]\s*\d+(?:\.\d+)?(?:\s*[+\-*\/]\s*\d+(?:\.\d+)?)*)/)
-        return math_expr[1].strip if math_expr
+      # Extracts a simple math expression (e.g., 2 + 2) from the prompt.
+      def extract_simple_math_expression(prompt)
+        math_expr = prompt.match(SIMPLE_MATH_PATTERN)
+        math_expr ? math_expr[1].strip : ""
+      end
 
-        # Ищем функции
-        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
+      # Extracts a function call (e.g., sqrt(16)) from the prompt.
+      def extract_function_call(prompt)
+        func_expr = prompt.match(FUNC_CALL_PATTERN)
+        func_expr ? func_expr[0] : ""
+      end
 
-        # Ищем выражение после ключевых слов
+      # Extracts an expression after a math keyword from the prompt.
+      def extract_keyword_expression(prompt)
         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
               if expr
                 cleaned = clean_expression(expr)
@@ -89,44 +157,47 @@ module LLMChain
             end
           end
         end
-
         ""
       end
 
+      # Cleans up a candidate expression, removing extra words and keeping only numbers and operators.
+      # @param expr [String]
+      # @return [String]
       def clean_expression(expr)
-        # Удаляем лишние слова но оставляем числа и операторы
-        cleaned = expr.gsub(/\b(is|what|equals?|result|answer|the)\b/i, '')
-                     .gsub(/[^\d+\-*\/().\s]/, ' ')  # заменяем на пробелы, не удаляем
-                     .gsub(/\s+/, ' ')  # убираем множественные пробелы
+        cleaned = expr.gsub(CLEAN_EXTRA_WORDS_PATTERN, '')
+                     .gsub(CLEAN_NON_MATH_PATTERN, ' ')
+                     .gsub(MULTIPLE_SPACES_PATTERN, ' ')
                      .strip
-        
-        # Проверяем что результат похож на математическое выражение
-        if cleaned.match?(/\d+(?:\.\d+)?\s*[+\-*\/]\s*\d+(?:\.\d+)?/)
+        if cleaned.match?(VALID_MATH_EXPRESSION_PATTERN)
           cleaned
         else
           ""
         end
       end
 
+      # Evaluates a mathematical expression, supporting common math functions.
+      # @param expression [String]
+      # @return [Numeric]
       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" }
-
-        # Безопасная оценка выражения
+        max_iterations = 10
+        max_iterations.times do
+          before = expr.dup
+          expr.gsub!(/(?<!Math\.)sqrt\s*\((.*?)\)/, 'Math.sqrt(\1)')
+          expr.gsub!(/(?<!Math\.)sin\s*\((.*?)\)/, 'Math.sin(\1)')
+          expr.gsub!(/(?<!Math\.)cos\s*\((.*?)\)/, 'Math.cos(\1)')
+          expr.gsub!(/(?<!Math\.)tan\s*\((.*?)\)/, 'Math.tan(\1)')
+          expr.gsub!(/(?<!Math\.)log\s*\((.*?)\)/, 'Math.log10(\1)')
+          expr.gsub!(/(?<!Math\.)ln\s*\((.*?)\)/, 'Math.log(\1)')
+          expr.gsub!(/(?<!Math\.)exp\s*\((.*?)\)/, 'Math.exp(\1)')
+          expr.gsub!(/(?<!\.)abs\s*\((.*?)\)/, '(\1).abs')
+          expr.gsub!(/(?<!\.)round\s*\((.*?)\)/, '(\1).round')
+          expr.gsub!(/(?<!\.)ceil\s*\((.*?)\)/, '(\1).ceil')
+          expr.gsub!(/(?<!\.)floor\s*\((.*?)\)/, '(\1).floor')
+          break if expr == before
+        end
+        puts "[DEBUG_CALC] Final eval expression: '#{expr}'" if ENV['DEBUG_CALC']
         result = safe_eval(expr)
-        
-        # Округляем результат до разумного количества знаков
         if result.is_a?(Float)
           result.round(10)
         else
@@ -134,18 +205,20 @@ module LLMChain
         end
       end
 
+      # Safely evaluates a mathematical expression.
+      # Only allows numbers, operators, parentheses, and supported Math methods.
+      # @param expression [String]
+      # @return [Numeric]
       def safe_eval(expression)
-        # Проверяем, что выражение содержит только безопасные символы
-        unless expression.match?(/\A[\d+\-*\/().\s]+\z/) || 
+        unless expression.match?(SAFE_EVAL_PATTERN) || 
                expression.include?('Math.') || 
-               expression.match?(/\.(abs|round|ceil|floor)\b/)
+               expression.match?(SAFE_EVAL_METHOD_PATTERN)
           raise "Unsafe expression: #{expression}"
         end
-
-        # Оцениваем выражение
         eval(expression)
       end
 
+      # @return [Array<String>]
       def required_parameters
         ['expression']
       end

data/lib/llm_chain/tools/code_interpreter.rb

@@ -3,7 +3,7 @@ require 'timeout'
 
 module LLMChain
   module Tools
-    class CodeInterpreter < BaseTool
+    class CodeInterpreter < Base
       KEYWORDS = %w[
         code run execute script program
         ruby python javascript
@@ -108,26 +108,26 @@ module LLMChain
       end
 
       def extract_code(prompt)
-        # Нормализуем line endings
+        # Normalize line endings (CRLF -> LF)
         normalized_prompt = normalize_line_endings(prompt)
         
-        # 1. Пробуем различные паттерны markdown блоков
+        # 1. Try various markdown block patterns
         code = extract_markdown_code_blocks(normalized_prompt)
         return clean_code(code) if code && !code.empty?
 
-        # 2. Ищем код после ключевых команд в одной строке
+        # 2. Attempt inline "run code:" patterns
         code = extract_inline_code_commands(normalized_prompt)
         return clean_code(code) if code && !code.empty?
 
-        # 3. Ищем код после ключевых слов в разных строках
+        # 3. Look for code after keywords across multiple lines
         code = extract_multiline_code_blocks(normalized_prompt)
         return clean_code(code) if code && !code.empty?
 
-        # 4. Ищем строки, которые выглядят как код
+        # 4. Fallback: detect code-like lines
         code = extract_code_like_lines(normalized_prompt)
         return clean_code(code) if code && !code.empty?
 
-        # 5. Последняя попытка - весь текст после первого кода
+        # 5. Last resort – everything after first code-looking line
         code = extract_fallback_code(normalized_prompt)
         clean_code(code)
       end
@@ -139,19 +139,19 @@ module LLMChain
       end
 
       def extract_markdown_code_blocks(prompt)
-        # Различные паттерны для markdown блоков
+        # Pattern list for markdown code blocks
         patterns = [
-          # Стандартный markdown с указанием языка
+          # Standard fenced block with language tag
           /```(?:ruby|python|javascript|js)\s*\n(.*?)\n```/mi,
-          # Markdown без указания языка
+          # Fenced block without language tag
           /```\s*\n(.*?)\n```/mi,
-          # Markdown с любым языком
+          # Fenced block any language
           /```\w*\s*\n(.*?)\n```/mi,
-          # Тильды вместо backticks
+          # Using ~~~ instead of ```
           /~~~(?:ruby|python|javascript|js)?\s*\n(.*?)\n~~~/mi,
-          # Без переносов строк
+          # Single-line fenced block
           /```(?:ruby|python|javascript|js)?(.*?)```/mi,
-          # Четыре пробела (indented code blocks)
+          # Indented code block (4 spaces)
           /^    (.+)$/m
         ]
         
@@ -164,7 +164,7 @@ module LLMChain
       end
 
       def extract_inline_code_commands(prompt)
-        # Команды в одной строке
+        # Inline "run code" commands
         inline_patterns = [
           /execute\s+code:\s*(.+)/i,
           /run\s+code:\s*(.+)/i,
@@ -189,30 +189,30 @@ module LLMChain
           keyword_line_index = lines.find_index { |line| line.downcase.include?(keyword.downcase) }
           next unless keyword_line_index
           
-          # Берем строки после ключевого слова
+          # Take lines after the keyword
           code_lines = lines[(keyword_line_index + 1)..-1]
           next unless code_lines
           
-          # Найдем первую непустую строку
+          # Find the first non-empty line
           first_code_line = code_lines.find_index { |line| !line.strip.empty? }
           next unless first_code_line
           
-          # Берем все строки начиная с первой непустой
+          # Take all lines starting from the first non-empty line
           relevant_lines = code_lines[first_code_line..-1]
           
-          # Определяем отступ первой строки кода
+          # Determine indentation of the first code line
           first_line = relevant_lines.first
           indent = first_line.match(/^(\s*)/)[1].length
           
-          # Собираем все строки с таким же или большим отступом
+          # Collect all lines with the same or greater indentation
           code_block = []
           relevant_lines.each do |line|
             if line.strip.empty?
-              code_block << "" # Сохраняем пустые строки
+              code_block << "" # Preserve empty lines
             elsif line.match(/^(\s*)/)[1].length >= indent
               code_block << line
             else
-              break # Прекращаем при уменьшении отступа
+              break # Stop when indentation decreases
             end
           end
           
@@ -229,26 +229,26 @@ module LLMChain
           stripped = line.strip
           next false if stripped.empty?
           
-          # Проверяем различные паттерны кода
+          # Check various code patterns
           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*\/\*.*\*\//) # Блочные комментарии
+          stripped.match?(/^\s*#.*/) ||  # Comments
+          stripped.match?(/^\s*\/\/.*/) || # JS comments
+          stripped.match?(/^\s*\/\*.*\*\//) # Block comments
         end
         
         code_lines.join("\n") if code_lines.any?
       end
 
       def extract_fallback_code(prompt)
-        # Последняя попытка - ищем что-то похожее на код
+        # Final attempt – look for anything resembling code
         lines = prompt.split("\n")
         
-        # Найдем первую строку, которая выглядит как код
+        # Find first line that looks like code
         start_index = lines.find_index do |line|
           stripped = line.strip
           stripped.match?(/^(def|class|function|puts|print|console\.log|var|let|const)/i) ||
@@ -258,14 +258,14 @@ module LLMChain
         
         return nil unless start_index
         
-        # Берем все строки после найденной
+        # Take all subsequent lines
         code_lines = lines[start_index..-1]
         
-        # Останавливаемся на первой строке, которая явно не код
+        # Stop when line clearly not code
         end_index = code_lines.find_index do |line|
           stripped = line.strip
-          stripped.match?(/^(что|как|где|когда|зачем|почему|what|how|where|when|why)/i) ||
-          stripped.length > 100 # Слишком длинная строка
+          stripped.match?(/^(что|как|где|когда|зачем|почему|what|how|where|when|why)/i) || # Russian/English question words
+          stripped.length > 100 # Too long -> unlikely code
         end
         
         relevant_lines = end_index ? code_lines[0...end_index] : code_lines
@@ -277,16 +277,16 @@ module LLMChain
         
         lines = code.strip.lines
         
-        # Удаляем только комментарии, которые не являются частью кода
+        # Remove pure comment lines, keep inline comments
         cleaned_lines = lines.reject do |line|
           stripped = line.strip
-          # Удаляем только строки, которые содержат ТОЛЬКО комментарии
-          stripped.match?(/^\s*#[^{]*$/) || # Ruby комментарии (но не интерполяция)
-          stripped.match?(/^\s*\/\/.*$/) || # JS комментарии
-          stripped.match?(/^\s*\/\*.*\*\/\s*$/) # Блочные комментарии
+          # Remove only lines that contain ONLY comments
+          stripped.match?(/^\s*#[^{]*$/) || # Ruby comments (excluding interpolation)
+          stripped.match?(/^\s*\/\/.*$/) || # JS comments
+          stripped.match?(/^\s*\/\*.*\*\/\s*$/) # Block comments
         end
         
-        # Убираем пустые строки в начале и конце, но сохраняем внутри
+        # Remove blank lines at the beginning and end, but keep them inside
         start_index = cleaned_lines.find_index { |line| !line.strip.empty? }
         return "" unless start_index
         
@@ -297,12 +297,12 @@ module LLMChain
       end
 
       def detect_language(code, prompt)
-        # Явное указание языка
+        # Explicit language specification
         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')
 
-        # Определение по синтаксису
+        # Determine by syntax
         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 ')
@@ -329,12 +329,12 @@ module LLMChain
 
       def execute_ruby(code)
         Timeout.timeout(@timeout) do
-          # Создаем временный файл
+          # Create a temporary file
           Tempfile.create(['code', '.rb']) do |file|
             file.write(code)
             file.flush
             
-            # Выполняем код в отдельном процессе
+            # Execute code in a separate process
             result = `ruby #{file.path} 2>&1`
             
             if $?.success?
@@ -369,7 +369,7 @@ module LLMChain
             file.write(code)
             file.flush
             
-            # Пробуем node.js
+            # Try node.js
             result = `node #{file.path} 2>&1`
             
             if $?.success?

data/lib/llm_chain/tools/date_time.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+require 'time'
+
+module LLMChain
+  module Tools
+    # Simple tool that returns current date and time.
+    class DateTime < Base
+      KEYWORDS = %w[time date today now current].freeze
+
+      def initialize
+        super(
+          name: "date_time",
+          description: "Returns current date and time (optionally for given timezone)",
+          parameters: {
+            timezone: {
+              type: "string",
+              description: "IANA timezone name, e.g. 'Europe/Moscow'. Defaults to system TZ"
+            }
+          }
+        )
+      end
+
+      # @param prompt [String]
+      # @return [Boolean]
+      def match?(prompt)
+        contains_keywords?(prompt, KEYWORDS)
+      end
+
+      # @param prompt [String]
+      # @param context [Hash]
+      def call(prompt, context: {})
+        params = extract_parameters(prompt)
+        tz = params[:timezone]
+        time = tz ? Time.now.getlocal(timezone_offset(tz)) : Time.now
+        {
+          timezone: tz || Time.now.zone,
+          iso: time.iso8601,
+          formatted: time.strftime("%Y-%m-%d %H:%M:%S %Z")
+        }
+      end
+
+      def extract_parameters(prompt)
+        tz_match = prompt.match(/in\s+([A-Za-z_\/]+)/)
+        { timezone: tz_match && tz_match[1] }
+      end
+
+      private
+
+      def timezone_offset(tz)
+        # Fallback: use TZInfo if available, else default to system
+        require 'tzinfo'
+        TZInfo::Timezone.get(tz).current_period.offset
+      rescue LoadError, TZInfo::InvalidTimezoneIdentifier
+        0
+      end
+    end
+  end
+end