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



64
65
66
67
68
69
70
 
# File 'lib/shared_tools/tools/calculator_tool.rb', line 64

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 



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

def self.name = 'calculator'

Instance Method Details

#available? ⇒ Boolean

Returns:

  • (Boolean) 


16
17
18
 
# File 'lib/shared_tools/tools/calculator_tool.rb', line 16

def available?
  DENTAKU_AVAILABLE
end

#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



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
129
130
131
132
133
134
135
136
137
138
 
# File 'lib/shared_tools/tools/calculator_tool.rb', line 78

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