langchain-core 0.3.0.dev4__tar.gz → 0.3.0.dev5__tar.gz

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-core
-Version: 0.3.0.dev4
+Version: 0.3.0.dev5
 Summary: Building applications with LLMs through composability
 Home-page: https://github.com/langchain-ai/langchain
 License: MIT
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: PyYAML (>=5.3)
 Requires-Dist: jsonpatch (>=1.33,<2.0)
-Requires-Dist: langsmith (>=0.1.112,<0.2.0)
+Requires-Dist: langsmith (>=0.1.117,<0.2.0)
 Requires-Dist: packaging (>=23.2,<25)
 Requires-Dist: pydantic (>=2.7.4,<3.0.0)
 Requires-Dist: tenacity (>=8.1.0,<9.0.0,!=8.4.0)

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/langchain_core/language_models/__init__.py

@@ -4,7 +4,7 @@ text prompts.
 LangChain has two main classes to work with language models: **Chat Models**
 and "old-fashioned" **LLMs**.
 
-## Chat Models
+**Chat Models**
 
 Language models that use a sequence of messages as inputs and return chat messages
 as outputs (as opposed to using plain text). These are traditionally newer models (
@@ -21,7 +21,7 @@ the following guide for more information on how to implement a custom Chat Model
 
 https://python.langchain.com/v0.2/docs/how_to/custom_chat_model/
 
-## LLMs
+**LLMs**
 
 Language models that takes a string as input and returns a string.
 These are traditionally older models (newer models generally are Chat Models, see below).
@@ -35,6 +35,8 @@ To implement a custom LLM, inherit from `BaseLLM` or `LLM`.
 Please see the following guide for more information on how to implement a custom LLM:
 
 https://python.langchain.com/v0.2/docs/how_to/custom_llm/
+
+
 """  # noqa: E501
 
 from langchain_core.language_models.base import (

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/langchain_core/language_models/base.py

@@ -113,10 +113,6 @@ class BaseLanguageModel(
     
     Caching is not currently supported for streaming methods of models.
     """
-    # Repr = False is consistent with pydantic 1 if verbose = False
-    # We can relax this for pydantic 2?
-    # TODO(0.3): Resolve repr for verbose
-    # Modified just to get unit tests to pass.
     verbose: bool = Field(default_factory=_get_verbosity, exclude=True, repr=False)
     """Whether to print out response text."""
     callbacks: Callbacks = Field(default=None, exclude=True)

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/langchain_core/language_models/chat_models.py

@@ -195,20 +195,14 @@ class BaseChatModel(BaseLanguageModel[BaseMessage], ABC):
 
     """  # noqa: E501
 
-    # TODO(0.3): Figure out how to re-apply deprecated decorator
-    # callback_manager: Optional[BaseCallbackManager] = deprecated(
-    #     name="callback_manager", since="0.1.7", removal="1.0", alternative="callbacks"
-    # )(
-    #     Field(
-    #         default=None,
-    #         exclude=True,
-    #         description="Callback manager to add to the run trace.",
-    #     )
-    # )
-    callback_manager: Optional[BaseCallbackManager] = Field(
-        default=None,
-        exclude=True,
-        description="Callback manager to add to the run trace.",
+    callback_manager: Optional[BaseCallbackManager] = deprecated(
+        name="callback_manager", since="0.1.7", removal="1.0", alternative="callbacks"
+    )(
+        Field(
+            default=None,
+            exclude=True,
+            description="Callback manager to add to the run trace.",
+        )
     )
 
     rate_limiter: Optional[BaseRateLimiter] = Field(default=None, exclude=True)
@@ -1180,7 +1174,7 @@ class BaseChatModel(BaseLanguageModel[BaseMessage], ABC):
         Example: Pydantic schema (include_raw=False):
             .. code-block:: python
 
-                from langchain_core.pydantic_v1 import BaseModel
+                from pydantic import BaseModel
 
                 class AnswerWithJustification(BaseModel):
                     '''An answer to the user question along with justification for the answer.'''
@@ -1200,7 +1194,7 @@ class BaseChatModel(BaseLanguageModel[BaseMessage], ABC):
         Example: Pydantic schema (include_raw=True):
             .. code-block:: python
 
-                from langchain_core.pydantic_v1 import BaseModel
+                from pydantic import BaseModel
 
                 class AnswerWithJustification(BaseModel):
                     '''An answer to the user question along with justification for the answer.'''
@@ -1220,7 +1214,7 @@ class BaseChatModel(BaseLanguageModel[BaseMessage], ABC):
         Example: Dict schema (include_raw=False):
             .. code-block:: python
 
-                from langchain_core.pydantic_v1 import BaseModel
+                from pydantic import BaseModel
                 from langchain_core.utils.function_calling import convert_to_openai_tool
 
                 class AnswerWithJustification(BaseModel):

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/langchain_core/messages/tool.py

@@ -1,7 +1,8 @@
 import json
 from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+from uuid import UUID
 
-from pydantic import Field
+from pydantic import Field, model_validator
 from typing_extensions import NotRequired, TypedDict
 
 from langchain_core.messages.base import BaseMessage, BaseMessageChunk, merge_content
@@ -82,15 +83,48 @@ class ToolMessage(BaseMessage):
         Default is ["langchain", "schema", "messages"]."""
         return ["langchain", "schema", "messages"]
 
+    @model_validator(mode="before")
+    @classmethod
+    def coerce_args(cls, values: dict) -> dict:
+        content = values["content"]
+        if isinstance(content, tuple):
+            content = list(content)
+
+        if not isinstance(content, (str, list)):
+            try:
+                values["content"] = str(content)
+            except ValueError as e:
+                raise ValueError(
+                    "ToolMessage content should be a string or a list of string/dicts. "
+                    f"Received:\n\n{content=}\n\n which could not be coerced into a "
+                    "string."
+                ) from e
+        elif isinstance(content, list):
+            values["content"] = []
+            for i, x in enumerate(content):
+                if not isinstance(x, (str, dict)):
+                    try:
+                        values["content"].append(str(x))
+                    except ValueError as e:
+                        raise ValueError(
+                            "ToolMessage content should be a string or a list of "
+                            "string/dicts. Received a list but "
+                            f"element ToolMessage.content[{i}] is not a dict and could "
+                            f"not be coerced to a string.:\n\n{x}"
+                        ) from e
+                else:
+                    values["content"].append(x)
+        else:
+            pass
+
+        tool_call_id = values["tool_call_id"]
+        if isinstance(tool_call_id, UUID):
+            values["tool_call_id"] = str(tool_call_id)
+        return values
+
     def __init__(
         self, content: Union[str, List[Union[str, Dict]]], **kwargs: Any
     ) -> None:
-        """Pass in content as positional arg.
-
-        Args:
-            content: The string contents of the message.
-            kwargs: Additional fields to pass to the message
-        """
         super().__init__(content=content, **kwargs)
 
 

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/langchain_core/messages/utils.py

@@ -50,7 +50,16 @@ if TYPE_CHECKING:
 
 
 def _get_type(v: Any) -> str:
-    return v.type
+    """Get the type associated with the object for serialization purposes."""
+    if isinstance(v, dict) and "type" in v:
+        return v["type"]
+    elif hasattr(v, "type"):
+        return v.type
+    else:
+        raise TypeError(
+            f"Expected either a dictionary with a 'type' key or an object "
+            f"with a 'type' attribute. Instead got type {type(v)}."
+        )
 
 
 AnyMessage = Annotated[
@@ -263,7 +272,7 @@ def _create_message_from_message_type(
         message = RemoveMessage(**kwargs)
     else:
         raise ValueError(
-            f"Unexpected message type: {message_type}. Use one of 'human',"
+            f"Unexpected message type: '{message_type}'. Use one of 'human',"
             f" 'user', 'ai', 'assistant', 'function', 'tool', or 'system'."
         )
     return message

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/langchain_core/outputs/llm_result.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from copy import deepcopy
-from typing import List, Optional, Union
+from typing import List, Literal, Optional, Union
 
 from pydantic import BaseModel
 
@@ -48,6 +48,9 @@ class LLMResult(BaseModel):
     run: Optional[List[RunInfo]] = None
     """List of metadata info for model call for each input."""
 
+    type: Literal["LLMResult"] = "LLMResult"  # type: ignore[assignment]
+    """Type is used exclusively for serialization purposes."""
+
     def flatten(self) -> List[LLMResult]:
         """Flatten generations into a single list.
 

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/langchain_core/pydantic_v1/__init__.py

@@ -1,5 +1,7 @@
 from importlib import metadata
 
+from langchain_core._api.deprecation import warn_deprecated
+
 ## Create namespaces for pydantic v1 and v2.
 # This code must stay at the top of the file before other modules may
 # attempt to import pydantic since it adds pydantic_v1 and pydantic_v2 to sys.modules.
@@ -21,3 +23,21 @@ try:
     _PYDANTIC_MAJOR_VERSION: int = int(metadata.version("pydantic").split(".")[0])
 except metadata.PackageNotFoundError:
     _PYDANTIC_MAJOR_VERSION = 0
+
+warn_deprecated(
+    "0.3.0",
+    removal="1.0.0",
+    alternative="pydantic.v1 or pydantic",
+    message=(
+        "As of langchain-core 0.3.0, LangChain uses pydantic v2 internally. "
+        "The langchain_core.pydantic_v1 module was a "
+        "compatibility shim for pydantic v1, and should no longer be used. "
+        "Please update the code to import from Pydantic directly.\n\n"
+        "For example, replace imports like: "
+        "`from langchain_core.pydantic_v1 import BaseModel`\n"
+        "with: `from pydantic import BaseModel`\n"
+        "or the v1 compatibility namespace if you are working in a code base "
+        "that has not been fully upgraded to pydantic 2 yet. "
+        "\tfrom pydantic.v1 import BaseModel\n"
+    ),
+)

langchain_core-0.3.0.dev5/langchain_core/pydantic_v1/dataclasses.py

@@ -0,0 +1,24 @@
+from langchain_core._api import warn_deprecated
+
+try:
+    from pydantic.v1.dataclasses import *  # noqa: F403
+except ImportError:
+    from pydantic.dataclasses import *  # type: ignore # noqa: F403
+
+warn_deprecated(
+    "0.3.0",
+    removal="1.0.0",
+    alternative="pydantic.v1 or pydantic",
+    message=(
+        "As of langchain-core 0.3.0, LangChain uses pydantic v2 internally. "
+        "The langchain_core.pydantic_v1 module was a "
+        "compatibility shim for pydantic v1, and should no longer be used. "
+        "Please update the code to import from Pydantic directly.\n\n"
+        "For example, replace imports like: "
+        "`from langchain_core.pydantic_v1 import BaseModel`\n"
+        "with: `from pydantic import BaseModel`\n"
+        "or the v1 compatibility namespace if you are working in a code base "
+        "that has not been fully upgraded to pydantic 2 yet. "
+        "\tfrom pydantic.v1 import BaseModel\n"
+    ),
+)

langchain_core-0.3.0.dev5/langchain_core/pydantic_v1/main.py

@@ -0,0 +1,24 @@
+from langchain_core._api import warn_deprecated
+
+try:
+    from pydantic.v1.main import *  # noqa: F403
+except ImportError:
+    from pydantic.main import *  # type: ignore # noqa: F403
+
+warn_deprecated(
+    "0.3.0",
+    removal="1.0.0",
+    alternative="pydantic.v1 or pydantic",
+    message=(
+        "As of langchain-core 0.3.0, LangChain uses pydantic v2 internally. "
+        "The langchain_core.pydantic_v1 module was a "
+        "compatibility shim for pydantic v1, and should no longer be used. "
+        "Please update the code to import from Pydantic directly.\n\n"
+        "For example, replace imports like: "
+        "`from langchain_core.pydantic_v1 import BaseModel`\n"
+        "with: `from pydantic import BaseModel`\n"
+        "or the v1 compatibility namespace if you are working in a code base "
+        "that has not been fully upgraded to pydantic 2 yet. "
+        "\tfrom pydantic.v1 import BaseModel\n"
+    ),
+)

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/langchain_core/runnables/base.py

@@ -348,6 +348,14 @@ class Runnable(Generic[Input, Output], ABC):
         return create_model(
             self.get_name("Input"),
             __root__=root_type,
+            # create model needs access to appropriate type annotations to be
+            # able to construct the pydantic model.
+            # When we create the model, we pass information about the namespace
+            # where the model is being created, so the type annotations can
+            # be resolved correctly as well.
+            # self.__class__.__module__ handles the case when the Runnable is
+            # being sub-classed in a different module.
+            __module_name=self.__class__.__module__,
         )
 
     def get_input_jsonschema(
@@ -408,6 +416,14 @@ class Runnable(Generic[Input, Output], ABC):
         return create_model(
             self.get_name("Output"),
             __root__=root_type,
+            # create model needs access to appropriate type annotations to be
+            # able to construct the pydantic model.
+            # When we create the model, we pass information about the namespace
+            # where the model is being created, so the type annotations can
+            # be resolved correctly as well.
+            # self.__class__.__module__ handles the case when the Runnable is
+            # being sub-classed in a different module.
+            __module_name=self.__class__.__module__,
         )
 
     def get_output_jsonschema(
@@ -1094,7 +1110,6 @@ class Runnable(Generic[Input, Output], ABC):
         ):
             yield item
 
-    @beta_decorator.beta(message="This API is in beta and may change in the future.")
     async def astream_events(
         self,
         input: Any,
@@ -2364,7 +2379,7 @@ class Runnable(Generic[Input, Output], ABC):
         .. code-block:: python
 
             from typing import Any, Dict, List
-            from langchain_core.pydantic_v1 import BaseModel, Field
+            from pydantic import BaseModel, Field
             from langchain_core.runnables import RunnableLambda
 
             def f(x: Dict[str, Any]) -> str:
@@ -4047,6 +4062,29 @@ class RunnableGenerator(Runnable[Input, Output]):
         except ValueError:
             return Any
 
+    def get_input_schema(
+        self, config: Optional[RunnableConfig] = None
+    ) -> Type[BaseModel]:
+        # Override the default implementation.
+        # For a runnable generator, we need to bring to provide the
+        # module of the underlying function when creating the model.
+        root_type = self.InputType
+
+        func = getattr(self, "_transform", None) or self._atransform
+        module = getattr(func, "__module__", None)
+
+        if inspect.isclass(root_type) and issubclass(root_type, BaseModel):
+            return root_type
+
+        return create_model(
+            self.get_name("Input"),
+            __root__=root_type,
+            # To create the schema, we need to provide the module
+            # where the underlying function is defined.
+            # This allows pydantic to resolve type annotations appropriately.
+            __module_name=module,
+        )
+
     @property
     def OutputType(self) -> Any:
         func = getattr(self, "_transform", None) or self._atransform
@@ -4060,6 +4098,28 @@ class RunnableGenerator(Runnable[Input, Output]):
         except ValueError:
             return Any
 
+    def get_output_schema(
+        self, config: Optional[RunnableConfig] = None
+    ) -> Type[BaseModel]:
+        # Override the default implementation.
+        # For a runnable generator, we need to bring to provide the
+        # module of the underlying function when creating the model.
+        root_type = self.OutputType
+        func = getattr(self, "_transform", None) or self._atransform
+        module = getattr(func, "__module__", None)
+
+        if inspect.isclass(root_type) and issubclass(root_type, BaseModel):
+            return root_type
+
+        return create_model(
+            self.get_name("Output"),
+            __root__=root_type,
+            # To create the schema, we need to provide the module
+            # where the underlying function is defined.
+            # This allows pydantic to resolve type annotations appropriately.
+            __module_name=module,
+        )
+
     def __eq__(self, other: Any) -> bool:
         if isinstance(other, RunnableGenerator):
             if hasattr(self, "_transform") and hasattr(other, "_transform"):
@@ -4308,9 +4368,14 @@ class RunnableLambda(Runnable[Input, Output]):
                 # It's a dict, lol
                 return create_model(self.get_name("Input"), **fields)
             else:
+                module = getattr(func, "__module__", None)
                 return create_model(
                     self.get_name("Input"),
                     __root__=List[Any],
+                    # To create the schema, we need to provide the module
+                    # where the underlying function is defined.
+                    # This allows pydantic to resolve type annotations appropriately.
+                    __module_name=module,
                 )
 
         if self.InputType != Any:
@@ -4347,6 +4412,28 @@ class RunnableLambda(Runnable[Input, Output]):
         except ValueError:
             return Any
 
+    def get_output_schema(
+        self, config: Optional[RunnableConfig] = None
+    ) -> Type[BaseModel]:
+        # Override the default implementation.
+        # For a runnable lambda, we need to bring to provide the
+        # module of the underlying function when creating the model.
+        root_type = self.OutputType
+        func = getattr(self, "func", None) or self.afunc
+        module = getattr(func, "__module__", None)
+
+        if inspect.isclass(root_type) and issubclass(root_type, BaseModel):
+            return root_type
+
+        return create_model(
+            self.get_name("Output"),
+            __root__=root_type,
+            # To create the schema, we need to provide the module
+            # where the underlying function is defined.
+            # This allows pydantic to resolve type annotations appropriately.
+            __module_name=module,
+        )
+
     @property
     def deps(self) -> List[Runnable]:
         """The dependencies of this Runnable.
@@ -4864,6 +4951,14 @@ class RunnableEachBase(RunnableSerializable[List[Input], List[Output]]):
                 List[self.bound.get_input_schema(config)],  # type: ignore
                 None,
             ),
+            # create model needs access to appropriate type annotations to be
+            # able to construct the pydantic model.
+            # When we create the model, we pass information about the namespace
+            # where the model is being created, so the type annotations can
+            # be resolved correctly as well.
+            # self.__class__.__module__ handles the case when the Runnable is
+            # being sub-classed in a different module.
+            __module_name=self.__class__.__module__,
         )
 
     @property
@@ -4877,6 +4972,14 @@ class RunnableEachBase(RunnableSerializable[List[Input], List[Output]]):
         return create_model(
             self.get_name("Output"),
             __root__=List[schema],  # type: ignore[valid-type]
+            # create model needs access to appropriate type annotations to be
+            # able to construct the pydantic model.
+            # When we create the model, we pass information about the namespace
+            # where the model is being created, so the type annotations can
+            # be resolved correctly as well.
+            # self.__class__.__module__ handles the case when the Runnable is
+            # being sub-classed in a different module.
+            __module_name=self.__class__.__module__,
         )
 
     @property

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/langchain_core/runnables/branch.py

@@ -138,13 +138,6 @@ class RunnableBranch(RunnableSerializable[Input, Output]):
         super().__init__(
             branches=_branches,
             default=default_,
-            # Hard-coding a name here because RunnableBranch is a generic
-            # and with pydantic 2, the class name with pydantic will capture
-            # include the parameterized type, which is not what we want.
-            # e.g., we'd get RunnableBranch[Input, Output] instead of RunnableBranch
-            # for the name. This information is already captured in the
-            # input and output types.
-            name="RunnableBranch",
         )  # type: ignore[call-arg]
 
     model_config = ConfigDict(

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/langchain_core/runnables/configurable.py

@@ -376,7 +376,6 @@ class RunnableConfigurableFields(DynamicRunnable[Input, Output]):
         Returns:
             List[ConfigurableFieldSpec]: The configuration specs.
         """
-        # TODO(0.3): This change removes field_info which isn't needed in pydantic 2
         config_specs = []
 
         for field_name, spec in self.fields.items():

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/langchain_core/runnables/graph_mermaid.py

@@ -11,6 +11,8 @@ from langchain_core.runnables.graph import (
     NodeStyles,
 )
 
+MARKDOWN_SPECIAL_CHARS = "*_`"
+
 
 def draw_mermaid(
     nodes: Dict[str, Node],
@@ -58,13 +60,19 @@ def draw_mermaid(
         default_class_label = "default"
         format_dict = {default_class_label: "{0}({1})"}
         if first_node is not None:
-            format_dict[first_node] = "{0}([{0}]):::first"
+            format_dict[first_node] = "{0}([{1}]):::first"
         if last_node is not None:
-            format_dict[last_node] = "{0}([{0}]):::last"
+            format_dict[last_node] = "{0}([{1}]):::last"
 
         # Add nodes to the graph
         for key, node in nodes.items():
-            label = node.name.split(":")[-1]
+            node_name = node.name.split(":")[-1]
+            label = (
+                f"<p>{node_name}</p>"
+                if node_name.startswith(tuple(MARKDOWN_SPECIAL_CHARS))
+                and node_name.endswith(tuple(MARKDOWN_SPECIAL_CHARS))
+                else node_name
+            )
             if node.metadata:
                 label = (
                     f"{label}<hr/><small><em>"
@@ -119,9 +127,9 @@ def draw_mermaid(
                         for i in range(0, len(words), wrap_label_n_words)
                     )
                 if edge.conditional:
-                    edge_label = f" -. &nbsp{edge_data}&nbsp .-> "
+                    edge_label = f" -. &nbsp;{edge_data}&nbsp; .-> "
                 else:
-                    edge_label = f" -- &nbsp{edge_data}&nbsp --> "
+                    edge_label = f" -- &nbsp;{edge_data}&nbsp; --> "
             else:
                 if edge.conditional:
                     edge_label = " -.-> "

{langchain_core-0.3.0.dev4 → langchain_core-0.3.0.dev5}/langchain_core/runnables/history.py

@@ -21,6 +21,7 @@ from langchain_core.runnables.base import Runnable, RunnableBindingBase, Runnabl
 from langchain_core.runnables.passthrough import RunnablePassthrough
 from langchain_core.runnables.utils import (
     ConfigurableFieldSpec,
+    Output,
     create_model,
     get_unique_config_specs,
 )
@@ -97,7 +98,7 @@ class RunnableWithMessageHistory(RunnableBindingBase):
         from langchain_core.documents import Document
         from langchain_core.messages import BaseMessage, AIMessage
         from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
-        from langchain_core.pydantic_v1 import BaseModel, Field
+        from pydantic import BaseModel, Field
         from langchain_core.runnables import (
             RunnableLambda,
             ConfigurableFieldSpec,
@@ -362,6 +363,7 @@ class RunnableWithMessageHistory(RunnableBindingBase):
             history_factory_config=_config_specs,
             **kwargs,
         )
+        self._history_chain = history_chain
 
     @property
     def config_specs(self) -> List[ConfigurableFieldSpec]:
@@ -373,9 +375,6 @@ class RunnableWithMessageHistory(RunnableBindingBase):
     def get_input_schema(
         self, config: Optional[RunnableConfig] = None
     ) -> Type[BaseModel]:
-        # TODO(0.3): Verify that this change was correct
-        # Not enough tests and unclear on why the previous implementation was
-        # necessary.
         from langchain_core.messages import BaseMessage
 
         fields: Dict = {}
@@ -393,6 +392,39 @@ class RunnableWithMessageHistory(RunnableBindingBase):
             **fields,
         )
 
+    @property
+    def OutputType(self) -> Type[Output]:
+        output_type = self._history_chain.OutputType
+        return output_type
+
+    def get_output_schema(
+        self, config: Optional[RunnableConfig] = None
+    ) -> Type[BaseModel]:
+        """Get a pydantic model that can be used to validate output to the Runnable.
+
+        Runnables that leverage the configurable_fields and configurable_alternatives
+        methods will have a dynamic output schema that depends on which
+        configuration the Runnable is invoked with.
+
+        This method allows to get an output schema for a specific configuration.
+
+        Args:
+            config: A config to use when generating the schema.
+
+        Returns:
+            A pydantic model that can be used to validate output.
+        """
+        root_type = self.OutputType
+
+        if inspect.isclass(root_type) and issubclass(root_type, BaseModel):
+            return root_type
+
+        return create_model(
+            "RunnableWithChatHistoryOutput",
+            __root__=root_type,
+            __module_name=self.__class__.__module__,
+        )
+
     def _is_not_async(self, *args: Sequence[Any], **kwargs: Dict[str, Any]) -> bool:
         return False