langchain-core 0.4.0.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

langchain_core/output_parsers/openai_functions.py

@@ -3,7 +3,7 @@
 import copy
 import json
 from types import GenericAlias
-from typing import Any, Optional, Union
+from typing import Any
 
 import jsonpatch  # type: ignore[import-untyped]
 from pydantic import BaseModel, model_validator
@@ -17,7 +17,6 @@ from langchain_core.output_parsers import (
 )
 from langchain_core.output_parsers.json import parse_partial_json
 from langchain_core.outputs import ChatGeneration, Generation
-from langchain_core.v1.messages import AIMessage
 
 
 class OutputFunctionsParser(BaseGenerationOutputParser[Any]):
@@ -27,27 +26,19 @@ class OutputFunctionsParser(BaseGenerationOutputParser[Any]):
     """Whether to only return the arguments to the function call."""
 
     @override
-    def parse_result(
-        self, result: Union[list[Generation], AIMessage], *, partial: bool = False
-    ) -> Any:
+    def parse_result(self, result: list[Generation], *, partial: bool = False) -> Any:
         """Parse the result of an LLM call to a JSON object.
 
         Args:
             result: The result of the LLM call.
-            partial: Whether to parse partial JSON objects. Default is False.
+            partial: Whether to parse partial JSON objects.
 
         Returns:
             The parsed JSON object.
 
         Raises:
-            OutputParserException: If the output is not valid JSON.
+            `OutputParserException`: If the output is not valid JSON.
         """
-        if isinstance(result, AIMessage):
-            msg = (
-                "This output parser does not support v1 AIMessages. Use "
-                "JsonOutputToolsParser instead."
-            )
-            raise TypeError(msg)
         generation = result[0]
         if not isinstance(generation, ChatGeneration):
             msg = "This output parser can only be used with a chat generation."
@@ -65,7 +56,7 @@ class OutputFunctionsParser(BaseGenerationOutputParser[Any]):
 
 
 class JsonOutputFunctionsParser(BaseCumulativeTransformOutputParser[Any]):
-    """Parse an output as the Json object."""
+    """Parse an output as the JSON object."""
 
     strict: bool = False
     """Whether to allow non-JSON-compliant strings.
@@ -83,30 +74,22 @@ class JsonOutputFunctionsParser(BaseCumulativeTransformOutputParser[Any]):
         return "json_functions"
 
     @override
-    def _diff(self, prev: Optional[Any], next: Any) -> Any:
+    def _diff(self, prev: Any | None, next: Any) -> Any:
         return jsonpatch.make_patch(prev, next).patch
 
-    def parse_result(
-        self, result: Union[list[Generation], AIMessage], *, partial: bool = False
-    ) -> Any:
+    def parse_result(self, result: list[Generation], *, partial: bool = False) -> Any:
         """Parse the result of an LLM call to a JSON object.
 
         Args:
             result: The result of the LLM call.
-            partial: Whether to parse partial JSON objects. Default is False.
+            partial: Whether to parse partial JSON objects.
 
         Returns:
             The parsed JSON object.
 
         Raises:
-            OutputParserException: If the output is not valid JSON.
+            OutputParserExcept`ion: If the output is not valid JSON.
         """
-        if isinstance(result, AIMessage):
-            msg = (
-                "This output parser does not support v1 AIMessages. Use "
-                "JsonOutputToolsParser instead."
-            )
-            raise TypeError(msg)
         if len(result) != 1:
             msg = f"Expected exactly one result, but got {len(result)}"
             raise OutputParserException(msg)
@@ -172,19 +155,17 @@ class JsonOutputFunctionsParser(BaseCumulativeTransformOutputParser[Any]):
 
 
 class JsonKeyOutputFunctionsParser(JsonOutputFunctionsParser):
-    """Parse an output as the element of the Json object."""
+    """Parse an output as the element of the JSON object."""
 
     key_name: str
     """The name of the key to return."""
 
-    def parse_result(
-        self, result: Union[list[Generation], AIMessage], *, partial: bool = False
-    ) -> Any:
+    def parse_result(self, result: list[Generation], *, partial: bool = False) -> Any:
         """Parse the result of an LLM call to a JSON object.
 
         Args:
             result: The result of the LLM call.
-            partial: Whether to parse partial JSON objects. Default is False.
+            partial: Whether to parse partial JSON objects.
 
         Returns:
             The parsed JSON object.
@@ -196,48 +177,50 @@ class JsonKeyOutputFunctionsParser(JsonOutputFunctionsParser):
 
 
 class PydanticOutputFunctionsParser(OutputFunctionsParser):
-    """Parse an output as a pydantic object.
+    """Parse an output as a Pydantic object.
 
-    This parser is used to parse the output of a ChatModel that uses
-    OpenAI function format to invoke functions.
+    This parser is used to parse the output of a chat model that uses OpenAI function
+    format to invoke functions.
 
-    The parser extracts the function call invocation and matches
-    them to the pydantic schema provided.
+    The parser extracts the function call invocation and matches them to the Pydantic
+    schema provided.
 
-    An exception will be raised if the function call does not match
-    the provided schema.
+    An exception will be raised if the function call does not match the provided schema.
 
     Example:
-        ... code-block:: python
-
-            message = AIMessage(
-                content="This is a test message",
-                additional_kwargs={
-                    "function_call": {
-                        "name": "cookie",
-                        "arguments": json.dumps({"name": "value", "age": 10}),
-                    }
-                },
-            )
-            chat_generation = ChatGeneration(message=message)
+        ```python
+        message = AIMessage(
+            content="This is a test message",
+            additional_kwargs={
+                "function_call": {
+                    "name": "cookie",
+                    "arguments": json.dumps({"name": "value", "age": 10}),
+                }
+            },
+        )
+        chat_generation = ChatGeneration(message=message)
 
-            class Cookie(BaseModel):
-                name: str
-                age: int
 
-            class Dog(BaseModel):
-                species: str
+        class Cookie(BaseModel):
+            name: str
+            age: int
+
+
+        class Dog(BaseModel):
+            species: str
 
-            # Full output
-            parser = PydanticOutputFunctionsParser(
-                pydantic_schema={"cookie": Cookie, "dog": Dog}
-            )
-            result = parser.parse_result([chat_generation])
+
+        # Full output
+        parser = PydanticOutputFunctionsParser(
+            pydantic_schema={"cookie": Cookie, "dog": Dog}
+        )
+        result = parser.parse_result([chat_generation])
+        ```
 
     """
 
-    pydantic_schema: Union[type[BaseModel], dict[str, type[BaseModel]]]
-    """The pydantic schema to parse the output with.
+    pydantic_schema: type[BaseModel] | dict[str, type[BaseModel]]
+    """The Pydantic schema to parse the output with.
 
     If multiple schemas are provided, then the function name will be used to
     determine which schema to use.
@@ -246,7 +229,7 @@ class PydanticOutputFunctionsParser(OutputFunctionsParser):
     @model_validator(mode="before")
     @classmethod
     def validate_schema(cls, values: dict) -> Any:
-        """Validate the pydantic schema.
+        """Validate the Pydantic schema.
 
         Args:
             values: The values to validate.
@@ -255,7 +238,7 @@ class PydanticOutputFunctionsParser(OutputFunctionsParser):
             The validated values.
 
         Raises:
-            ValueError: If the schema is not a pydantic schema.
+            ValueError: If the schema is not a Pydantic schema.
         """
         schema = values["pydantic_schema"]
         if "args_only" not in values:
@@ -273,14 +256,15 @@ class PydanticOutputFunctionsParser(OutputFunctionsParser):
         return values
 
     @override
-    def parse_result(
-        self, result: Union[list[Generation], AIMessage], *, partial: bool = False
-    ) -> Any:
+    def parse_result(self, result: list[Generation], *, partial: bool = False) -> Any:
         """Parse the result of an LLM call to a JSON object.
 
         Args:
             result: The result of the LLM call.
-            partial: Whether to parse partial JSON objects. Default is False.
+            partial: Whether to parse partial JSON objects.
+
+        Raises:
+            ValueError: If the Pydantic schema is not valid.
 
         Returns:
             The parsed JSON object.
@@ -303,26 +287,24 @@ class PydanticOutputFunctionsParser(OutputFunctionsParser):
             elif issubclass(pydantic_schema, BaseModelV1):
                 pydantic_args = pydantic_schema.parse_raw(args)
             else:
-                msg = f"Unsupported pydantic schema: {pydantic_schema}"
+                msg = f"Unsupported Pydantic schema: {pydantic_schema}"
                 raise ValueError(msg)
         return pydantic_args
 
 
 class PydanticAttrOutputFunctionsParser(PydanticOutputFunctionsParser):
-    """Parse an output as an attribute of a pydantic object."""
+    """Parse an output as an attribute of a Pydantic object."""
 
     attr_name: str
     """The name of the attribute to return."""
 
     @override
-    def parse_result(
-        self, result: Union[list[Generation], AIMessage], *, partial: bool = False
-    ) -> Any:
+    def parse_result(self, result: list[Generation], *, partial: bool = False) -> Any:
         """Parse the result of an LLM call to a JSON object.
 
         Args:
             result: The result of the LLM call.
-            partial: Whether to parse partial JSON objects. Default is False.
+            partial: Whether to parse partial JSON objects.
 
         Returns:
             The parsed JSON object.

langchain_core/output_parsers/openai_tools.py

@@ -4,7 +4,7 @@ import copy
 import json
 import logging
 from json import JSONDecodeError
-from typing import Annotated, Any, Optional, Union
+from typing import Annotated, Any
 
 from pydantic import SkipValidation, ValidationError
 
@@ -16,7 +16,6 @@ from langchain_core.output_parsers.transform import BaseCumulativeTransformOutpu
 from langchain_core.outputs import ChatGeneration, Generation
 from langchain_core.utils.json import parse_partial_json
 from langchain_core.utils.pydantic import TypeBaseModel
-from langchain_core.v1.messages import AIMessage as AIMessageV1
 
 logger = logging.getLogger(__name__)
 
@@ -27,15 +26,14 @@ def parse_tool_call(
     partial: bool = False,
     strict: bool = False,
     return_id: bool = True,
-) -> Optional[dict[str, Any]]:
+) -> dict[str, Any] | None:
     """Parse a single tool call.
 
     Args:
         raw_tool_call: The raw tool call to parse.
-        partial: Whether to parse partial JSON. Default is False.
+        partial: Whether to parse partial JSON.
         strict: Whether to allow non-JSON-compliant strings.
-            Default is False.
-        return_id: Whether to return the tool call id. Default is True.
+        return_id: Whether to return the tool call id.
 
     Returns:
         The parsed tool call.
@@ -76,7 +74,7 @@ def parse_tool_call(
 
 def make_invalid_tool_call(
     raw_tool_call: dict[str, Any],
-    error_msg: Optional[str],
+    error_msg: str | None,
 ) -> InvalidToolCall:
     """Create an InvalidToolCall from a raw tool call.
 
@@ -106,10 +104,9 @@ def parse_tool_calls(
 
     Args:
         raw_tool_calls: The raw tool calls to parse.
-        partial: Whether to parse partial JSON. Default is False.
+        partial: Whether to parse partial JSON.
         strict: Whether to allow non-JSON-compliant strings.
-            Default is False.
-        return_id: Whether to return the tool call id. Default is True.
+        return_id: Whether to return the tool call id.
 
     Returns:
         The parsed tool calls.
@@ -149,7 +146,7 @@ class JsonOutputToolsParser(BaseCumulativeTransformOutputParser[Any]):
     first_tool_only: bool = False
     """Whether to return only the first tool call.
 
-    If False, the result will be a list of tool calls, or an empty list
+    If `False`, the result will be a list of tool calls, or an empty list
     if no tool calls are found.
 
     If true, and multiple tool calls are found, only the first one will be returned,
@@ -157,18 +154,15 @@ class JsonOutputToolsParser(BaseCumulativeTransformOutputParser[Any]):
     If no tool calls are found, None will be returned.
     """
 
-    def parse_result(
-        self, result: Union[list[Generation], AIMessageV1], *, partial: bool = False
-    ) -> Any:
+    def parse_result(self, result: list[Generation], *, partial: bool = False) -> Any:
         """Parse the result of an LLM call to a list of tool calls.
 
         Args:
             result: The result of the LLM call.
             partial: Whether to parse partial JSON.
-                If True, the output will be a JSON object containing
+                If `True`, the output will be a JSON object containing
                 all the keys that have been returned so far.
-                If False, the output will be the full JSON object.
-                Default is False.
+                If `False`, the output will be the full JSON object.
 
         Returns:
             The parsed tool calls.
@@ -176,45 +170,31 @@ class JsonOutputToolsParser(BaseCumulativeTransformOutputParser[Any]):
         Raises:
             OutputParserException: If the output is not valid JSON.
         """
-        if isinstance(result, list):
-            generation = result[0]
-            if not isinstance(generation, ChatGeneration):
-                msg = (
-                    "This output parser can only be used with a chat generation or "
-                    "v1 AIMessage."
-                )
-                raise OutputParserException(msg)
-            message = generation.message
-            if isinstance(message, AIMessage) and message.tool_calls:
-                tool_calls = [dict(tc) for tc in message.tool_calls]
-                for tool_call in tool_calls:
-                    if not self.return_id:
-                        _ = tool_call.pop("id")
-            else:
-                try:
-                    raw_tool_calls = copy.deepcopy(
-                        message.additional_kwargs["tool_calls"]
-                    )
-                except KeyError:
-                    return []
-                tool_calls = parse_tool_calls(
-                    raw_tool_calls,
-                    partial=partial,
-                    strict=self.strict,
-                    return_id=self.return_id,
-                )
-        elif result.tool_calls:
-            # v1 message
-            tool_calls = [dict(tc) for tc in result.tool_calls]
+        generation = result[0]
+        if not isinstance(generation, ChatGeneration):
+            msg = "This output parser can only be used with a chat generation."
+            raise OutputParserException(msg)
+        message = generation.message
+        if isinstance(message, AIMessage) and message.tool_calls:
+            tool_calls = [dict(tc) for tc in message.tool_calls]
             for tool_call in tool_calls:
                 if not self.return_id:
                     _ = tool_call.pop("id")
         else:
-            return []
-
+            try:
+                raw_tool_calls = copy.deepcopy(message.additional_kwargs["tool_calls"])
+            except KeyError:
+                return []
+            tool_calls = parse_tool_calls(
+                raw_tool_calls,
+                partial=partial,
+                strict=self.strict,
+                return_id=self.return_id,
+            )
         # for backwards compatibility
         for tc in tool_calls:
             tc["type"] = tc.pop("name")
+
         if self.first_tool_only:
             return tool_calls[0] if tool_calls else None
         return tool_calls
@@ -237,63 +217,50 @@ class JsonOutputKeyToolsParser(JsonOutputToolsParser):
     key_name: str
     """The type of tools to return."""
 
-    def parse_result(
-        self, result: Union[list[Generation], AIMessageV1], *, partial: bool = False
-    ) -> Any:
+    def parse_result(self, result: list[Generation], *, partial: bool = False) -> Any:
         """Parse the result of an LLM call to a list of tool calls.
 
         Args:
             result: The result of the LLM call.
             partial: Whether to parse partial JSON.
-                If True, the output will be a JSON object containing
+                If `True`, the output will be a JSON object containing
                 all the keys that have been returned so far.
-                If False, the output will be the full JSON object.
-                Default is False.
+                If `False`, the output will be the full JSON object.
+
+        Raises:
+            OutputParserException: If the generation is not a chat generation.
 
         Returns:
             The parsed tool calls.
         """
-        if isinstance(result, list):
-            generation = result[0]
-            if not isinstance(generation, ChatGeneration):
-                msg = "This output parser can only be used with a chat generation."
-                raise OutputParserException(msg)
-            message = generation.message
-            if isinstance(message, AIMessage) and message.tool_calls:
-                parsed_tool_calls = [dict(tc) for tc in message.tool_calls]
-                for tool_call in parsed_tool_calls:
-                    if not self.return_id:
-                        _ = tool_call.pop("id")
-            else:
-                try:
-                    raw_tool_calls = copy.deepcopy(
-                        message.additional_kwargs["tool_calls"]
-                    )
-                except KeyError:
-                    if self.first_tool_only:
-                        return None
-                    return []
-                parsed_tool_calls = parse_tool_calls(
-                    raw_tool_calls,
-                    partial=partial,
-                    strict=self.strict,
-                    return_id=self.return_id,
-                )
-        elif result.tool_calls:
-            # v1 message
-            parsed_tool_calls = [dict(tc) for tc in result.tool_calls]
+        generation = result[0]
+        if not isinstance(generation, ChatGeneration):
+            msg = "This output parser can only be used with a chat generation."
+            raise OutputParserException(msg)
+        message = generation.message
+        if isinstance(message, AIMessage) and message.tool_calls:
+            parsed_tool_calls = [dict(tc) for tc in message.tool_calls]
             for tool_call in parsed_tool_calls:
                 if not self.return_id:
                     _ = tool_call.pop("id")
         else:
-            if self.first_tool_only:
-                return None
-            return []
-
+            try:
+                # This exists purely for backward compatibility / cached messages
+                # All new messages should use `message.tool_calls`
+                raw_tool_calls = copy.deepcopy(message.additional_kwargs["tool_calls"])
+            except KeyError:
+                if self.first_tool_only:
+                    return None
+                return []
+            parsed_tool_calls = parse_tool_calls(
+                raw_tool_calls,
+                partial=partial,
+                strict=self.strict,
+                return_id=self.return_id,
+            )
         # For backwards compatibility
         for tc in parsed_tool_calls:
             tc["type"] = tc.pop("name")
-
         if self.first_tool_only:
             parsed_result = list(
                 filter(lambda x: x["type"] == self.key_name, parsed_tool_calls)
@@ -333,24 +300,23 @@ class PydanticToolsParser(JsonOutputToolsParser):
 
     # TODO: Support more granular streaming of objects. Currently only streams once all
     # Pydantic object fields are present.
-    def parse_result(
-        self, result: Union[list[Generation], AIMessageV1], *, partial: bool = False
-    ) -> Any:
+    def parse_result(self, result: list[Generation], *, partial: bool = False) -> Any:
         """Parse the result of an LLM call to a list of Pydantic objects.
 
         Args:
             result: The result of the LLM call.
             partial: Whether to parse partial JSON.
-                If True, the output will be a JSON object containing
+                If `True`, the output will be a JSON object containing
                 all the keys that have been returned so far.
-                If False, the output will be the full JSON object.
-                Default is False.
+                If `False`, the output will be the full JSON object.
 
         Returns:
             The parsed Pydantic objects.
 
         Raises:
-            OutputParserException: If the output is not valid JSON.
+            ValueError: If the tool call arguments are not a dict.
+            ValidationError: If the tool call arguments do not conform
+                to the Pydantic model.
         """
         json_results = super().parse_result(result, partial=partial)
         if not json_results:
@@ -373,19 +339,12 @@ class PydanticToolsParser(JsonOutputToolsParser):
             except (ValidationError, ValueError):
                 if partial:
                     continue
-                has_max_tokens_stop_reason = False
-                if isinstance(result, list):
-                    has_max_tokens_stop_reason = any(
-                        generation.message.response_metadata.get("stop_reason")
-                        == "max_tokens"
-                        for generation in result
-                        if isinstance(generation, ChatGeneration)
-                    )
-                else:
-                    # v1 message
-                    has_max_tokens_stop_reason = (
-                        result.response_metadata.get("stop_reason") == "max_tokens"
-                    )
+                has_max_tokens_stop_reason = any(
+                    generation.message.response_metadata.get("stop_reason")
+                    == "max_tokens"
+                    for generation in result
+                    if isinstance(generation, ChatGeneration)
+                )
                 if has_max_tokens_stop_reason:
                     logger.exception(_MAX_TOKENS_ERROR)
                 raise

langchain_core/output_parsers/pydantic.py

@@ -1,7 +1,7 @@
 """Output parsers using Pydantic."""
 
 import json
-from typing import Annotated, Generic, Optional, Union
+from typing import Annotated, Generic
 
 import pydantic
 from pydantic import SkipValidation
@@ -14,14 +14,13 @@ from langchain_core.utils.pydantic import (
     PydanticBaseModel,
     TBaseModel,
 )
-from langchain_core.v1.messages import AIMessage
 
 
 class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):
-    """Parse an output using a pydantic model."""
+    """Parse an output using a Pydantic model."""
 
     pydantic_object: Annotated[type[TBaseModel], SkipValidation()]
-    """The pydantic model to parse."""
+    """The Pydantic model to parse."""
 
     def _parse_obj(self, obj: dict) -> TBaseModel:
         try:
@@ -44,19 +43,22 @@ class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):
         return OutputParserException(msg, llm_output=json_string)
 
     def parse_result(
-        self, result: Union[list[Generation], AIMessage], *, partial: bool = False
-    ) -> Optional[TBaseModel]:
-        """Parse the result of an LLM call to a pydantic object.
+        self, result: list[Generation], *, partial: bool = False
+    ) -> TBaseModel | None:
+        """Parse the result of an LLM call to a Pydantic object.
 
         Args:
             result: The result of the LLM call.
             partial: Whether to parse partial JSON objects.
-                If True, the output will be a JSON object containing
+                If `True`, the output will be a JSON object containing
                 all the keys that have been returned so far.
-                Defaults to False.
+
+        Raises:
+            `OutputParserException`: If the result is not valid JSON
+                or does not conform to the Pydantic model.
 
         Returns:
-            The parsed pydantic object.
+            The parsed Pydantic object.
         """
         try:
             json_object = super().parse_result(result)
@@ -67,13 +69,13 @@ class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):
             raise
 
     def parse(self, text: str) -> TBaseModel:
-        """Parse the output of an LLM call to a pydantic object.
+        """Parse the output of an LLM call to a Pydantic object.
 
         Args:
             text: The output of the LLM call.
 
         Returns:
-            The parsed pydantic object.
+            The parsed Pydantic object.
         """
         return super().parse(text)
 
@@ -104,7 +106,7 @@ class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):
     @property
     @override
     def OutputType(self) -> type[TBaseModel]:
-        """Return the pydantic model."""
+        """Return the Pydantic model."""
         return self.pydantic_object
 
 

langchain_core/output_parsers/string.py

@@ -1,5 +1,7 @@
 """String output parser."""
 
+from typing_extensions import override
+
 from langchain_core.output_parsers.transform import BaseTransformOutputParser
 
 
@@ -17,9 +19,10 @@ class StrOutputParser(BaseTransformOutputParser[str]):
 
     @classmethod
     def get_lc_namespace(cls) -> list[str]:
-        """Get the namespace of the langchain object.
+        """Get the namespace of the LangChain object.
 
-        Default is ["langchain", "schema", "output_parser"].
+        Returns:
+            `["langchain", "schema", "output_parser"]`
         """
         return ["langchain", "schema", "output_parser"]
 
@@ -28,6 +31,7 @@ class StrOutputParser(BaseTransformOutputParser[str]):
         """Return the output parser type for serialization."""
         return "default"
 
+    @override
     def parse(self, text: str) -> str:
         """Returns the input text with no changes."""
         return text