update calculator tool (#132)

* minor readme update

* updated the calculator tool
- docs
- tests
- how a tool is called returning success/fail
- exception handling

README.md

@@ -4,6 +4,7 @@ Elixir LangChain enables Elixir applications to integrate AI services and self-h
 
 Currently supported AI services:
 - OpenAI ChatGPT
+- OpenAI DALL-e 2 - image generation
 - Anthropic Claude
 - Google AI - https://generativelanguage.googleapis.com
 - Google Vertex AI - Gemini

lib/tools/calculator.ex

@@ -12,8 +12,8 @@ defmodule LangChain.Tools.Calculator do
 
   * make repeated calls to run the chain as the tool is called and the results
   are then made available to the LLM before it returns the final result.
-  * OR run the chain using the `while_needs_response: true` option like this:
-    `LangChain.LLMChain.run(chain, while_needs_response: true)`
+  * OR run the chain using the `mode: :until_success` option like this:
+    `LangChain.LLMChain.run(chain, mode: :until_success)`
 
 
   ## Example
@@ -28,7 +28,7 @@ defmodule LangChain.Tools.Calculator do
           Message.new_user!("Answer the following math question: What is 100 + 300 - 200?")
         )
         |> LLMChain.add_functions(Calculator.new!())
-        |> LLMChain.run(while_needs_response: true)
+        |> LLMChain.run(mode: :until_success)
 
   Verbose log output:
 
@@ -165,18 +165,24 @@ defmodule LangChain.Tools.Calculator do
   Performs the calculation specified in the expression and returns the response
   to be used by the the LLM.
   """
-  @spec execute(args :: %{String.t() => any()}, context :: map()) :: String.t()
+  @spec execute(args :: %{String.t() => any()}, context :: map()) ::
+          {:ok, String.t()} | {:error, String.t()}
   def execute(%{"expression" => expr} = _args, _context) do
-    case Abacus.eval(expr) do
-      {:ok, number} ->
-        to_string(number)
-
-      {:error, reason} ->
-        Logger.warning(
-          "Calculator tool errored in eval of #{inspect(expr)}. Reason: #{inspect(reason)}"
-        )
-
-        "ERROR"
+    try do
+      case Abacus.eval(expr) do
+        {:ok, number} ->
+          {:ok, to_string(number)}
+
+        {:error, reason} ->
+          Logger.warning(
+            "Calculator tool errored in eval of #{inspect(expr)}. Reason: #{inspect(reason)}"
+          )
+
+          {:error, "ERROR: #{inspect(expr)} is not a valid expression"}
+      end
+    rescue
+      err ->
+        {:error, "ERROR: An invalid expression raised the exception #{inspect(err)}"}
     end
   end
 end

test/tools/calculator_test.exs

@@ -29,7 +29,7 @@ defmodule LangChain.Tools.CalculatorTest do
 
     test "assigned function can be executed" do
       {:ok, calc} = Calculator.new()
-      assert "3" == calc.function.(%{"expression" => "1 + 2"}, nil)
+      assert {:ok, "3"} == calc.function.(%{"expression" => "1 + 2"}, nil)
     end
   end
 
@@ -41,7 +41,7 @@ defmodule LangChain.Tools.CalculatorTest do
 
   describe "execute/2" do
     test "evaluates the expression returning the result" do
-      assert "14" == Calculator.execute(%{"expression" => "1 + 2 + 3 + (2 * 4)"}, nil)
+      assert {:ok, "14"} == Calculator.execute(%{"expression" => "1 + 2 + 3 + (2 * 4)"}, nil)
     end
 
     test "returns an error when evaluation fails" do
@@ -50,7 +50,16 @@ defmodule LangChain.Tools.CalculatorTest do
           Calculator.execute(%{"expression" => "cow + dog"}, nil)
         end)
 
-      assert "ERROR" == result
+      assert {:error, "ERROR: \"cow + dog\" is not a valid expression"} == result
+    end
+
+    test "handles when a partial expression is given" do
+      assert {:ok, "-200"} = Calculator.execute(%{"expression" => "- 200"}, nil)
+    end
+
+    test "handles when an invalid arithmetic expression is given" do
+      assert {:error, reason} = Calculator.execute(%{"expression" => "5 / 0"}, nil)
+      assert reason == "ERROR: \"5 / 0\" is not a valid expression"
     end
   end
 
@@ -59,20 +68,31 @@ defmodule LangChain.Tools.CalculatorTest do
     test "performs repeated calls until complete with a live LLM" do
       test_pid = self()
 
-      callback = fn %Message{} = msg ->
-        send(test_pid, {:callback_msg, msg})
-      end
+      llm_handler = %{
+        on_llm_new_message: fn _model, %Message{} = message ->
+          send(test_pid, {:callback_msg, message})
+        end
+      }
+
+      chain_handler = %{
+        on_tool_response_created: fn _chain, %Message{} = tool_message ->
+          send(test_pid, {:callback_tool_msg, tool_message})
+        end
+      }
+
+      model = ChatOpenAI.new!(%{seed: 0, temperature: 0, stream: false, callbacks: [llm_handler]})
 
       {:ok, updated_chain, %Message{} = message} =
         LLMChain.new!(%{
-          llm: ChatOpenAI.new!(%{seed: 0, temperature: 0, stream: false}),
-          verbose: true
+          llm: model,
+          verbose: true,
+          callbacks: [chain_handler]
         })
         |> LLMChain.add_message(
           Message.new_user!("Answer the following math question: What is 100 + 300 - 200?")
         )
         |> LLMChain.add_tools(Calculator.new!())
-        |> LLMChain.run(while_needs_response: true, callback_fn: callback)
+        |> LLMChain.run(mode: :while_needs_response)
 
       assert updated_chain.last_message == message
       assert message.role == :assistant
@@ -86,7 +106,7 @@ defmodule LangChain.Tools.CalculatorTest do
       assert [%ToolCall{name: "calculator", arguments: %{"expression" => _}}] = message.tool_calls
 
       # the function result message
-      assert_received {:callback_msg, message}
+      assert_received {:callback_tool_msg, message}
       assert message.role == :tool
       assert [%ToolResult{content: "200"}] = message.tool_results