chore: Delint

Author: anubhav756

packages/toolbox-llamaindex/src/toolbox_llamaindex/async_tools.py

@@ -48,6 +48,9 @@ def __init__(
 
     @property
     def metadata(self) -> ToolMetadata:
+        if self.__core_tool.__doc__ is None:
+            raise ValueError("No description found for the tool.")
+
         return ToolMetadata(
             name=self.__core_tool.__name__,
             description=self.__core_tool.__doc__,
@@ -70,7 +73,13 @@ async def acall(self, **kwargs: Any) -> ToolOutput:  # type: ignore
             A dictionary containing the parsed JSON response from the tool
             invocation.
         """
-        return await self.__core_tool(**kwargs)
+        output_content = await self.__core_tool(**kwargs)
+        return ToolOutput(
+            content=output_content,
+            tool_name=self.__core_tool.__name__,
+            raw_input=kwargs,
+            raw_output=output_content,
+        )
 
     def add_auth_token_getters(
         self, auth_token_getters: dict[str, Callable[[], str]]

packages/toolbox-llamaindex/src/toolbox_llamaindex/tools.py

@@ -38,7 +38,6 @@ def __init__(
         Args:
             core_tool: The underlying core sync ToolboxTool instance.
         """
-
         # Due to how pydantic works, we must initialize the underlying
         # AsyncBaseTool class before assigning values to member variables.
         super().__init__()
@@ -47,7 +46,9 @@ def __init__(
 
     @property
     def metadata(self) -> ToolMetadata:
-        async_tool = self.__async_tool
+        if self.__core_tool.__doc__ is None:
+            raise ValueError("No description found for the tool.")
+
         return ToolMetadata(
             name=self.__core_tool.__name__,
             description=self.__core_tool.__doc__,
@@ -57,10 +58,22 @@ def metadata(self) -> ToolMetadata:
         )
 
     def call(self, **kwargs: Any) -> ToolOutput:  # type: ignore
-        return self.__core_tool(**kwargs)
+        output_content = self.__core_tool(**kwargs)
+        return ToolOutput(
+            content=output_content,
+            tool_name=self.__core_tool.__name__,
+            raw_input=kwargs,
+            raw_output=output_content,
+        )
 
     async def acall(self, **kwargs: Any) -> ToolOutput:  # type: ignore
-        return await to_thread(self.__core_tool, **kwargs)
+        output_content = await to_thread(self.__core_tool, **kwargs)
+        return ToolOutput(
+            content=output_content,
+            tool_name=self.__core_tool.__name__,
+            raw_input=kwargs,
+            raw_output=output_content,
+        )
 
     def add_auth_token_getters(
         self, auth_token_getters: dict[str, Callable[[], str]]

packages/toolbox-llamaindex/tests/test_async_client.py

@@ -136,7 +136,7 @@ async def test_aload_tool(
         )
         assert isinstance(tool, AsyncToolboxTool)
         assert (
-            tool.name == tool_name
+            tool.metadata.name == tool_name
         )  # AsyncToolboxTool gets its name from the core_tool
 
     async def test_aload_tool_auth_headers_deprecated(self, mock_client):
@@ -236,7 +236,7 @@ async def test_aload_toolset(self, mock_client):
         assert len(tools) == 2
         for tool in tools:
             assert isinstance(tool, AsyncToolboxTool)
-            assert tool.name in ["test_tool_1", "test_tool_2"]
+            assert tool.metadata.name in ["test_tool_1", "test_tool_2"]
 
     async def test_aload_toolset_with_toolset_name(self, mock_client):
         toolset_name = "test_toolset_1"

packages/toolbox-llamaindex/tests/test_async_tools.py

@@ -130,8 +130,8 @@ async def test_toolbox_tool_init(self, MockClientSession, tool_schema_dict):
             url="https://test-url",
         )
         tool = AsyncToolboxTool(core_tool=core_tool_instance)
-        assert tool.name == "test_tool"
-        assert tool.description == core_tool_instance.__doc__
+        assert tool.metadata.name == "test_tool"
+        assert tool.metadata.description == core_tool_instance.__doc__
 
     @pytest.mark.parametrize(
         "params_to_bind",
@@ -257,10 +257,10 @@ async def test_toolbox_tool_call_requires_auth_strict(self, auth_toolbox_tool):
             PermissionError,
             match="One or more of the following authn services are required to invoke this tool: test-auth-source",
         ):
-            await auth_toolbox_tool.acall({"param2": 123})
+            await auth_toolbox_tool.acall(param2=123)
 
     async def test_toolbox_tool_call(self, toolbox_tool):
-        result = await toolbox_tool.acall({"param1": "test-value", "param2": 123})
+        result = await toolbox_tool.acall(param1="test-value", param2=123)
         assert result == "test-result"
         core_tool = toolbox_tool._AsyncToolboxTool__core_tool
         core_tool._ToolboxTool__session.post.assert_called_once_with(
@@ -280,7 +280,7 @@ async def test_toolbox_tool_call_with_bound_params(
         self, toolbox_tool, bound_param_map, expected_value
     ):
         tool = toolbox_tool.bind_params(bound_param_map)
-        result = await tool.acall({"param2": 123})
+        result = await tool.acall(param2=123)
         assert result == "test-result"
         core_tool = tool._AsyncToolboxTool__core_tool
         core_tool._ToolboxTool__session.post.assert_called_once_with(
@@ -293,7 +293,7 @@ async def test_toolbox_tool_call_with_auth_tokens(self, auth_toolbox_tool):
         tool = auth_toolbox_tool.add_auth_token_getters(
             {"test-auth-source": lambda: "test-token"}
         )
-        result = await tool.acall({"param2": 123})
+        result = await tool.acall(param2=123)
         assert result == "test-result"
         core_tool = tool._AsyncToolboxTool__core_tool
         core_tool._ToolboxTool__session.post.assert_called_once_with(
@@ -324,7 +324,7 @@ async def test_toolbox_tool_call_with_auth_tokens_insecure(
         tool_with_getter = insecure_auth_langchain_tool.add_auth_token_getters(
             {"test-auth-source": lambda: "test-token"}
         )
-        result = await tool_with_getter.acall({"param2": 123})
+        result = await tool_with_getter.acall(param2=123)
         assert result == "test-result"
 
         modified_core_tool_in_new_tool = tool_with_getter._AsyncToolboxTool__core_tool
@@ -342,20 +342,18 @@ async def test_toolbox_tool_call_with_auth_tokens_insecure(
             headers={"test-auth-source_token": "test-token"},
         )
 
+    async def test_toolbox_tool_call_with_empty_input(self, toolbox_tool):
+        with pytest.raises(TypeError) as e:
+            await toolbox_tool.acall()
+        assert "missing a required argument: 'param1'" in str(e.value)
+
     async def test_toolbox_tool_call_with_invalid_input(self, toolbox_tool):
         with pytest.raises(ValidationError) as e:
-            await toolbox_tool.acall({"param1": 123, "param2": "invalid"})
+            await toolbox_tool.acall(param1=123, param2="invalid")
         assert "2 validation errors for test_tool" in str(e.value)
         assert "param1\n  Input should be a valid string" in str(e.value)
         assert "param2\n  Input should be a valid integer" in str(e.value)
 
-    async def test_toolbox_tool_call_with_empty_input(self, toolbox_tool):
-        with pytest.raises(ValidationError) as e:
-            await toolbox_tool.acall({})
-        assert "2 validation errors for test_tool" in str(e.value)
-        assert "param1\n  Field required" in str(e.value)
-        assert "param2\n  Field required" in str(e.value)
-
     async def test_toolbox_tool_run_not_implemented(self, toolbox_tool):
         with pytest.raises(NotImplementedError):
-            toolbox_tool._run()
+            toolbox_tool.call()

packages/toolbox-llamaindex/tests/test_client.py

@@ -115,16 +115,16 @@ def test_load_tool(self, mock_core_load_tool, toolbox_client):
         llamaindex_tool = toolbox_client.load_tool("test_tool")
 
         assert isinstance(llamaindex_tool, ToolboxTool)
-        assert llamaindex_tool.name == mock_core_tool_instance.__name__
-        assert llamaindex_tool.description == mock_core_tool_instance.__doc__
+        assert llamaindex_tool.metadata.name == mock_core_tool_instance.__name__
+        assert llamaindex_tool.metadata.description == mock_core_tool_instance.__doc__
 
         # Generate the expected schema once for comparison
         expected_args_schema = params_to_pydantic_model(
             mock_core_tool_instance._name, mock_core_tool_instance._params
         )
 
         assert_pydantic_models_equivalent(
-            llamaindex_tool.args_schema,
+            llamaindex_tool.metadata.fn_schema,
             expected_args_schema,
             mock_core_tool_instance._name,
         )
@@ -154,14 +154,14 @@ def test_load_toolset(self, mock_core_load_toolset, toolbox_client):
         for i, tool_instance_mock in enumerate(tool_instances_mocks):
             llamaindex_tool = llamaindex_tools[i]
             assert isinstance(llamaindex_tool, ToolboxTool)
-            assert llamaindex_tool.name == tool_instance_mock.__name__
-            assert llamaindex_tool.description == tool_instance_mock.__doc__
+            assert llamaindex_tool.metadata.name == tool_instance_mock.__name__
+            assert llamaindex_tool.metadata.description == tool_instance_mock.__doc__
 
             expected_args_schema = params_to_pydantic_model(
                 tool_instance_mock._name, tool_instance_mock._params
             )
             assert_pydantic_models_equivalent(
-                llamaindex_tool.args_schema,
+                llamaindex_tool.metadata.fn_schema,
                 expected_args_schema,
                 tool_instance_mock._name,
             )
@@ -183,14 +183,16 @@ async def test_aload_tool(self, mock_sync_core_load_tool, toolbox_client):
         llamaindex_tool = await toolbox_client.aload_tool("test_tool")
 
         assert isinstance(llamaindex_tool, ToolboxTool)
-        assert llamaindex_tool.name == mock_core_sync_tool_instance.__name__
-        assert llamaindex_tool.description == mock_core_sync_tool_instance.__doc__
+        assert llamaindex_tool.metadata.name == mock_core_sync_tool_instance.__name__
+        assert (
+            llamaindex_tool.metadata.description == mock_core_sync_tool_instance.__doc__
+        )
 
         expected_args_schema = params_to_pydantic_model(
             mock_core_sync_tool_instance._name, mock_core_sync_tool_instance._params
         )
         assert_pydantic_models_equivalent(
-            llamaindex_tool.args_schema,
+            llamaindex_tool.metadata.fn_schema,
             expected_args_schema,
             mock_core_sync_tool_instance._name,
         )
@@ -224,13 +226,13 @@ async def test_aload_toolset(self, mock_sync_core_load_toolset, toolbox_client):
         for i, tool_instance_mock in enumerate(tool_instances_mocks):
             llamaindex_tool = llamaindex_tools[i]
             assert isinstance(llamaindex_tool, ToolboxTool)
-            assert llamaindex_tool.name == tool_instance_mock.__name__
+            assert llamaindex_tool.metadata.name == tool_instance_mock.__name__
 
             expected_args_schema = params_to_pydantic_model(
                 tool_instance_mock._name, tool_instance_mock._params
             )
             assert_pydantic_models_equivalent(
-                llamaindex_tool.args_schema,
+                llamaindex_tool.metadata.fn_schema,
                 expected_args_schema,
                 tool_instance_mock._name,
             )

packages/toolbox-llamaindex/tests/test_tools.py

@@ -180,15 +180,15 @@ def auth_toolbox_tool(self, mock_core_sync_auth_tool):
     def test_toolbox_tool_init(self, mock_core_tool):
         tool = ToolboxTool(core_tool=mock_core_tool)
 
-        assert tool.name == mock_core_tool.__name__
-        assert tool.description == mock_core_tool.__doc__
+        assert tool.metadata.name == mock_core_tool.__name__
+        assert tool.metadata.description == mock_core_tool.__doc__
         assert tool._ToolboxTool__core_tool == mock_core_tool
 
         expected_args_schema = params_to_pydantic_model(
             mock_core_tool._name, mock_core_tool._params
         )
         assert_pydantic_models_equivalent(
-            tool.args_schema, expected_args_schema, mock_core_tool._name
+            tool.metadata.fn_schema, expected_args_schema, mock_core_tool._name
         )
 
     @pytest.mark.parametrize(
@@ -274,7 +274,7 @@ def test_toolbox_tool_run(self, toolbox_tool, mock_core_tool):
         expected_result = "sync_run_output"
         mock_core_tool.return_value = expected_result
 
-        result = toolbox_tool._run(**kwargs_to_run)
+        result = toolbox_tool.call(**kwargs_to_run)
 
         assert result == expected_result
         assert mock_core_tool.call_count == 1
@@ -295,7 +295,7 @@ async def to_thread_side_effect(func, *args, **kwargs_for_func):
 
         mock_to_thread_in_tools.side_effect = to_thread_side_effect
 
-        result = await toolbox_tool._arun(**kwargs_to_run)
+        result = await toolbox_tool.acall(**kwargs_to_run)
 
         assert result == expected_result
         mock_to_thread_in_tools.assert_awaited_once_with(