core: improved method tools

libs/core/langchain_core/tools/__init__.py

@@ -44,6 +44,7 @@
 from langchain_core.tools.convert import (
     convert_runnable_to_tool as convert_runnable_to_tool,
 )
+from langchain_core.tools.convert import methodtool as methodtool
 from langchain_core.tools.convert import tool as tool
 from langchain_core.tools.render import ToolsRenderer as ToolsRenderer
 from langchain_core.tools.render import (

libs/core/langchain_core/tools/convert.py

@@ -1,11 +1,21 @@
+import functools
 import inspect
-from typing import Any, Callable, Literal, Optional, Union, get_type_hints, overload
+from typing import (
+    Any,
+    Callable,
+    Literal,
+    Optional,
+    Union,
+    cast,
+    get_type_hints,
+    overload,
+)
 
 from pydantic import BaseModel, Field, create_model
 
 from langchain_core.callbacks import Callbacks
 from langchain_core.runnables import Runnable
-from langchain_core.tools.base import BaseTool
+from langchain_core.tools.base import BaseTool, create_schema_from_function
 from langchain_core.tools.simple import Tool
 from langchain_core.tools.structured import StructuredTool
 
@@ -421,3 +431,46 @@ def invoke_wrapper(callbacks: Optional[Callbacks] = None, **kwargs: Any) -> Any:
             description=description,
             args_schema=args_schema,
         )
+
+
+class MethodTool:
+    """A descriptor that converts a method into a tool."""
+
+    def __init__(self, func: Union[Callable, classmethod]) -> None:
+        self.func = func
+
+    def __get__(self, instance: Any, owner: Any) -> BaseTool:
+        # casting to Callable to avoid mypy error
+        tool_func: Callable = cast(
+            Callable,
+            self.func.__func__ if isinstance(self.func, classmethod) else self.func,
+        )
+        outer_instance = owner if isinstance(self.func, classmethod) else instance
+
+        new_func = functools.partial(tool_func, outer_instance)
+        new_func.__doc__ = tool_func.__doc__
+
+        # remove the first argument (typically 'self' or 'cls') from the schema
+        args_schema = create_schema_from_function(
+            tool_func.__name__,
+            tool_func,
+            filter_args=[
+                list(inspect.signature(tool_func).parameters.values())[0].name
+            ],
+        )
+
+        return tool(tool_func.__name__, args_schema=args_schema, infer_schema=False)(
+            new_func
+        )
+
+
+def methodtool(func: Union[Callable, classmethod]) -> MethodTool:
+    """Convert a method into a tool.
+
+    Args:
+        func: The method to convert.
+
+    Returns:
+        The method tool.
+    """
+    return MethodTool(func)

libs/core/tests/unit_tests/test_tools.py

@@ -43,6 +43,7 @@
     StructuredTool,
     Tool,
     ToolException,
+    methodtool,
     tool,
 )
 from langchain_core.tools.base import (
@@ -2174,3 +2175,163 @@ def foo(x: int) -> Bar:
     assert foo.invoke(
         {"type": "tool_call", "args": {"x": 0}, "name": "foo", "id": "bar"}
     ) == Bar(x=0)
+
+
+def test_method_tool_self_ref() -> None:
+    """Test that a method tool can reference self."""
+
+    class A:
+        def __init__(self, c: int):
+            self.c = c
+
+        @methodtool
+        def foo(self, a: int, b: int) -> int:
+            """Add two numbers to c."""
+            return a + b + self.c
+
+    a = A(10)
+    assert a.foo.invoke({"a": 1, "b": 2}) == 13
+    assert a.foo.args == {
+        "a": {"title": "A", "type": "integer"},
+        "b": {"title": "B", "type": "integer"},
+    }
+    assert a.foo.name == "foo"
+    assert a.foo.description == "Add two numbers to c."
+
+
+async def test_method_tool_async() -> None:
+    """Test that a method tool can be async."""
+
+    class A:
+        def __init__(self, c: int):
+            self.c = c
+
+        @methodtool
+        async def foo(self, a: int, b: int) -> int:
+            """Add two numbers to c."""
+            return a + b + self.c
+
+    a = A(10)
+    async_response = await a.foo.ainvoke({"a": 1, "b": 2})
+    assert async_response == 13
+    assert a.foo.args == {
+        "a": {"title": "A", "type": "integer"},
+        "b": {"title": "B", "type": "integer"},
+    }
+    assert a.foo.name == "foo"
+    assert a.foo.description == "Add two numbers to c."
+
+
+def test_method_tool_string_invoke() -> None:
+    """Test that a method tool can be invoked with a string."""
+
+    class A:
+        def __init__(self, a: str):
+            self.a = a
+
+        @methodtool
+        def foo(self, b: str) -> str:
+            """Concatenate a and b."""
+            return self.a + b
+
+    a = A("a")
+    assert a.foo.invoke("b") == "ab"
+    assert a.foo.args == {"b": {"title": "B", "type": "string"}}
+    assert a.foo.name == "foo"
+    assert a.foo.description == "Concatenate a and b."
+
+
+def test_method_tool_toolcall_invoke() -> None:
+    """Test that a method tool can be invoked with a ToolCall."""
+
+    class A:
+        def __init__(self, c: int):
+            self.c = c
+
+        @methodtool
+        def foo(self, a: int, b: int) -> int:
+            """Add two numbers to c."""
+            return a + b + self.c
+
+    a = A(10)
+
+    tool_call = {
+        "name": a.foo.name,
+        "args": {"a": 1, "b": 2},
+        "id": "123",
+        "type": "tool_call",
+    }
+
+    tool_message = a.foo.invoke(tool_call)
+
+    assert int(tool_message.content) == 13
+    assert a.foo.args == {
+        "a": {"title": "A", "type": "integer"},
+        "b": {"title": "B", "type": "integer"},
+    }
+    assert a.foo.name == "foo"
+    assert a.foo.description == "Add two numbers to c."
+
+
+def test_method_tool_classmethod() -> None:
+    """Test that a method tool can be a classmethod."""
+
+    class A:
+        c = 10
+
+        @methodtool
+        @classmethod
+        def foo(cls, a: int, b: int) -> int:
+            """Add two numbers to c."""
+            return a + b + cls.c
+
+    assert A.foo.invoke({"a": 1, "b": 2}) == 13
+    assert A.foo.args == {
+        "a": {"title": "A", "type": "integer"},
+        "b": {"title": "B", "type": "integer"},
+    }
+    assert A.foo.name == "foo"
+    assert A.foo.description == "Add two numbers to c."
+
+
+def test_method_tool_nonstandard_self() -> None:
+    """Test that a method tool can use a non-standard self name."""
+
+    class A:
+        def __init__(self, c: int):
+            self.c = c
+
+        @methodtool
+        def foo(s, a: int, b: int) -> int:  # noqa: N805
+            """Add two numbers to c."""
+            return a + b + s.c
+
+    a = A(10)
+    assert a.foo.invoke({"a": 1, "b": 2}) == 13
+    assert a.foo.args == {
+        "a": {"title": "A", "type": "integer"},
+        "b": {"title": "B", "type": "integer"},
+    }
+    assert a.foo.name == "foo"
+    assert a.foo.description == "Add two numbers to c."
+
+
+def test_method_tool_nonstandard_cls() -> None:
+    """Test that a classmethod tool can use a non-standard cls name."""
+
+    class A:
+        c = 10
+
+        @methodtool
+        @classmethod
+        def foo(c, a: int, b: int) -> int:  # noqa: N804
+            """Add two numbers to c."""
+            return a + b + c.c
+
+    assert A.foo.invoke({"a": 1, "b": 2}) == 13
+    assert A.foo.args == {
+        "a": {"title": "A", "type": "integer"},
+        "b": {"title": "B", "type": "integer"},
+    }
+    assert A.foo.name == "foo"
+    assert A.foo.description == "Add two numbers to c."