core[minor], integrations...[patch]: Support ToolCall as Tool input and ToolMessage as Tool output

libs/community/tests/unit_tests/tools/test_signatures.py

@@ -39,7 +39,7 @@ def get_non_abstract_subclasses(cls: Type[BaseTool]) -> List[Type[BaseTool]]:
 def test_all_subclasses_accept_run_manager(cls: Type[BaseTool]) -> None:
     """Test that tools defined in this repo accept a run manager argument."""
     # This wouldn't be necessary if the BaseTool had a strict API.
-    if cls._run is not BaseTool._arun:
+    if cls._run is not BaseTool._run:
         run_func = cls._run
         params = inspect.signature(run_func).parameters
         assert "run_manager" in params

libs/core/langchain_core/messages/tool.py

@@ -1,7 +1,7 @@
 import json
 from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
-from typing_extensions import TypedDict
+from typing_extensions import NotRequired, TypedDict
 
 from langchain_core.messages.base import BaseMessage, BaseMessageChunk, merge_content
 from langchain_core.utils._merge import merge_dicts, merge_obj
@@ -146,6 +146,11 @@ class ToolCall(TypedDict):
     An identifier is needed to associate a tool call request with a tool
     call result in events when multiple concurrent tool calls are made.
     """
+    type: NotRequired[Literal["tool_call"]]
+
+
+def tool_call(*, name: str, args: Dict[str, Any], id: Optional[str]) -> ToolCall:
+    return ToolCall(name=name, args=args, id=id, type="tool_call")
 
 
 class ToolCallChunk(TypedDict):
@@ -176,6 +181,19 @@ class ToolCallChunk(TypedDict):
     """An identifier associated with the tool call."""
     index: Optional[int]
     """The index of the tool call in a sequence."""
+    type: NotRequired[Literal["tool_call_chunk"]]
+
+
+def tool_call_chunk(
+    *,
+    name: Optional[str] = None,
+    args: Optional[str] = None,
+    id: Optional[str] = None,
+    index: Optional[int] = None,
+) -> ToolCallChunk:
+    return ToolCallChunk(
+        name=name, args=args, id=id, index=index, type="tool_call_chunk"
+    )
 
 
 class InvalidToolCall(TypedDict):
@@ -193,6 +211,19 @@ class InvalidToolCall(TypedDict):
     """An identifier associated with the tool call."""
     error: Optional[str]
     """An error message associated with the tool call."""
+    type: NotRequired[Literal["invalid_tool_call"]]
+
+
+def invalid_tool_call(
+    *,
+    name: Optional[str] = None,
+    args: Optional[str] = None,
+    id: Optional[str] = None,
+    error: Optional[str] = None,
+) -> InvalidToolCall:
+    return InvalidToolCall(
+        name=name, args=args, id=id, error=error, type="invalid_tool_call"
+    )
 
 
 def default_tool_parser(

libs/core/langchain_core/output_parsers/openai_tools.py

@@ -5,6 +5,12 @@
 
 from langchain_core.exceptions import OutputParserException
 from langchain_core.messages import AIMessage, InvalidToolCall
+from langchain_core.messages.tool import (
+    invalid_tool_call,
+)
+from langchain_core.messages.tool import (
+    tool_call as create_tool_call,
+)
 from langchain_core.output_parsers.transform import BaseCumulativeTransformOutputParser
 from langchain_core.outputs import ChatGeneration, Generation
 from langchain_core.pydantic_v1 import BaseModel, ValidationError
@@ -59,6 +65,7 @@ def parse_tool_call(
     }
     if return_id:
         parsed["id"] = raw_tool_call.get("id")
+        parsed = create_tool_call(**parsed)  # type: ignore
     return parsed
 
 
@@ -75,7 +82,7 @@ def make_invalid_tool_call(
     Returns:
         An InvalidToolCall instance with the error message.
     """
-    return InvalidToolCall(
+    return invalid_tool_call(
         name=raw_tool_call["function"]["name"],
         args=raw_tool_call["function"]["arguments"],
         id=raw_tool_call.get("id"),