Class: SharedTools::Tools::CalculatorTool

Inherits:
RubyLLM::Tool
  • Object
show all
Defined in:
lib/shared_tools/tools/calculator_tool.rb

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(logger: nil) ⇒ CalculatorTool

Returns a new instance of CalculatorTool.

Parameters:

  • logger (Logger) (defaults to: nil) —

    optional logger



54
55
56
57
58
59
60
 
# File 'lib/shared_tools/tools/calculator_tool.rb', line 54

def initialize(logger: nil)
  @logger = logger || RubyLLM.logger
  @calculator = Dentaku::Calculator.new

  # Enable case-insensitive function names
  Dentaku.enable_caching!
end

Class Method Details

.name ⇒ Object 



8
 
# File 'lib/shared_tools/tools/calculator_tool.rb', line 8

def self.name = 'calculator'

Instance Method Details

#execute(expression:, precision: 2) ⇒ Hash

Execute mathematical calculation

Parameters:

  • expression (String) —

    Mathematical expression to evaluate

  • precision (Integer) (defaults to: 2) —

    Number of decimal places (0-10), default 2

Returns:

  • (Hash) —

    Calculation result with success status



68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
 
# File 'lib/shared_tools/tools/calculator_tool.rb', line 68

def execute(expression:, precision: 2)
  @logger.info("CalculatorTool#execute expression=#{expression.inspect} precision=#{precision}")

  begin
    # Validate precision
    precision = validate_precision(precision)

    # Evaluate expression safely using Dentaku
    result = @calculator.evaluate(expression)

    # Handle nil result (invalid expression)
    unless result
      raise Dentaku::ParseError, "Could not parse expression"
    end

    # Format result with specified precision
    formatted_result = format_result(result, precision)

    @logger.info("Calculation successful: #{expression} = #{formatted_result}")

    {
      success:    true,
      result:     formatted_result,
      expression: expression,
      precision:  precision,
      raw_result: result
    }
  rescue Dentaku::ParseError => e
    @logger.error("Parse error for expression '#{expression}': #{e.message}")
    {
      success:    false,
      error:      "Invalid expression: #{e.message}",
      expression: expression,
      suggestion: "Try expressions like '2 + 2', '(10 * 5) / 2', or 'sqrt(16)'"
    }
  rescue Dentaku::ArgumentError => e
    @logger.error("Argument error for expression '#{expression}': #{e.message}")
    {
      success:    false,
      error:      "Invalid arguments: #{e.message}",
      expression: expression,
      suggestion: "Check that functions have the correct number of arguments"
    }
  rescue ZeroDivisionError => e
    @logger.error("Division by zero in expression '#{expression}'")
    {
      success:    false,
      error:      "Division by zero",
      expression: expression,
      suggestion: "Ensure the denominator is not zero"
    }
  rescue => e
    @logger.error("Calculation failed for '#{expression}': #{e.message}")
    {
      success:    false,
      error:      "Calculation error: #{e.message}",
      expression: expression,
      suggestion: "Verify the expression syntax and try again"
    }
  end
end