[feat] More specific error handling with simple function tools (#184)

* update AsyncSimpleFunctionTool error handling

* update SimpleFunctionTool error handling

* changelog

* coverage

Author: nerdai

CHANGELOG.md

@@ -17,6 +17,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/).
 
 ### Changed
 
+- [feat] More specific error handling with simple function tools (#184)
 - refactor: Store custom desc in _desc for SimpleFunctionTool and AsyncSimpleFunctionTool. (#181)
 - Remove return_history param in OllamaLLM.chat() (#126)
 - Rename continue_conversation_with_tool_results to continue_chat_with_tool_results (#123)

src/llm_agents_from_scratch/tools/simple_function.py

@@ -1,9 +1,10 @@
 """Simple Function Tool."""
 
 import inspect
+import json
 from typing import Any, Awaitable, Callable, get_type_hints
 
-from jsonschema import validate
+from jsonschema import SchemaError, ValidationError, validate
 
 from llm_agents_from_scratch.base.tool import AsyncBaseTool, BaseTool
 from llm_agents_from_scratch.data_structures import ToolCall, ToolCallResult
@@ -125,18 +126,35 @@ def __call__(
         try:
             # validate the arguments
             validate(tool_call.arguments, schema=self.parameters_json_schema)
+        except (SchemaError, ValidationError) as e:
+            error_details = {
+                "error_type": e.__class__.__name__,
+                "message": e.message,
+            }
+            return ToolCallResult(
+                tool_call_id=tool_call.id_,
+                content=json.dumps(error_details),
+                error=True,
+            )
+
+        try:
             # execute the function
             res = self.func(**tool_call.arguments)
-            content = str(res)
-            error = False
         except Exception as e:
-            content = f"Failed to execute function call: {e}"
-            error = True
+            error_details = {
+                "error_type": e.__class__.__name__,
+                "message": f"Internal error while executing tool: {str(e)}",
+            }
+            return ToolCallResult(
+                tool_call_id=tool_call.id_,
+                content=json.dumps(error_details),
+                error=True,
+            )
 
         return ToolCallResult(
             tool_call_id=tool_call.id_,
-            content=content,
-            error=error,
+            content=str(res),
+            error=False,
         )
 
 
@@ -198,16 +216,33 @@ async def __call__(
         try:
             # validate the arguments
             validate(tool_call.arguments, schema=self.parameters_json_schema)
+        except (SchemaError, ValidationError) as e:
+            error_details = {
+                "error_type": e.__class__.__name__,
+                "message": e.message,
+            }
+            return ToolCallResult(
+                tool_call_id=tool_call.id_,
+                content=json.dumps(error_details),
+                error=True,
+            )
+
+        try:
             # execute the function
             res = await self.func(**tool_call.arguments)
-            content = str(res)
-            error = False
         except Exception as e:
-            content = f"Failed to execute function call: {e}"
-            error = True
+            error_details = {
+                "error_type": e.__class__.__name__,
+                "message": f"Internal error while executing tool: {str(e)}",
+            }
+            return ToolCallResult(
+                tool_call_id=tool_call.id_,
+                content=json.dumps(error_details),
+                error=True,
+            )
 
         return ToolCallResult(
             tool_call_id=tool_call.id_,
-            content=content,
-            error=error,
+            content=str(res),
+            error=False,
         )

tests/tools/test_function_tool.py

@@ -38,6 +38,15 @@ async def my_mock_fn_3(
     return f"{param1} and {param2}"
 
 
+def my_mock_fn_that_raises(
+    param1: int,
+    param2: str = "x",
+    *args: Any,
+    **kwargs: Any,
+) -> str:
+    raise RuntimeError("Oops!")
+
+
 @pytest.mark.parametrize(
     ("func", "properties", "required"),
     [
@@ -114,7 +123,7 @@ def test_function_tool_call(mock_validate: MagicMock) -> None:
     assert result.error is False
 
 
-def test_function_tool_call_returns_error() -> None:
+def test_function_tool_call_returns_validation_error() -> None:
     """Tests a function tool call raises error at validation of params."""
     tool = SimpleFunctionTool(my_mock_fn_1, desc="mock desc")
     tool_call = ToolCall(
@@ -124,10 +133,29 @@ def test_function_tool_call_returns_error() -> None:
 
     result = tool(tool_call=tool_call)
 
-    assert (
-        "Failed to execute function call: '1' is not of type 'number'"
-        in result.content
+    expected_content = (
+        '{"error_type": "ValidationError", "message": "\'1\' '
+        "is not of type 'number'\"}"
     )
+    assert expected_content == result.content
+    assert result.error is True
+
+
+def test_function_tool_call_returns_execution_error() -> None:
+    """Tests a function tool call raises error at validation of params."""
+    tool = SimpleFunctionTool(my_mock_fn_that_raises, desc="mock desc")
+    tool_call = ToolCall(
+        tool_name="my_mock_fn_that_raises",
+        arguments={"param1": 1, "param2": "y"},
+    )
+
+    result = tool(tool_call=tool_call)
+
+    expected_content = (
+        '{"error_type": "RuntimeError", '
+        '"message": "Internal error while executing tool: Oops!"}'
+    )
+    assert expected_content == result.content
     assert result.error is True
 
 
@@ -166,7 +194,7 @@ async def test_async_function_tool_call(mock_validate: MagicMock) -> None:
 
 
 @pytest.mark.asyncio
-async def test_async_function_tool_call_returns_error() -> None:
+async def test_async_function_tool_call_returns_validation_error() -> None:
     """Tests a function tool call."""
     tool = AsyncSimpleFunctionTool(my_mock_fn_1, desc="mock desc")
     tool_call = ToolCall(
@@ -176,8 +204,29 @@ async def test_async_function_tool_call_returns_error() -> None:
 
     result = await tool(tool_call=tool_call)
 
-    assert (
-        "Failed to execute function call: '1' is not of type 'number'"
-        in result.content
+    expected_content = (
+        '{"error_type": "ValidationError", "message": "\'1\' '
+        "is not of type 'number'\"}"
+    )
+
+    assert expected_content == result.content
+    assert result.error is True
+
+
+@pytest.mark.asyncio
+async def test_async_function_tool_call_returns_execution_error() -> None:
+    """Tests a function tool call raises error at validation of params."""
+    tool = AsyncSimpleFunctionTool(my_mock_fn_that_raises, desc="mock desc")
+    tool_call = ToolCall(
+        tool_name="my_mock_fn_that_raises",
+        arguments={"param1": 1, "param2": "y"},
+    )
+
+    result = await tool(tool_call=tool_call)
+
+    expected_content = (
+        '{"error_type": "RuntimeError", '
+        '"message": "Internal error while executing tool: Oops!"}'
     )
+    assert expected_content == result.content
     assert result.error is True