langchain 0.3.27__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

langchain/chat_models/base.py

@@ -1,52 +1,38 @@
 from __future__ import annotations
 
 import warnings
-from collections.abc import AsyncIterator, Iterator, Sequence
 from importlib import util
 from typing import (
+    TYPE_CHECKING,
     Any,
-    Callable,
     Literal,
-    Optional,
+    TypeAlias,
     Union,
     cast,
     overload,
 )
 
-from langchain_core.language_models import (
-    BaseChatModel,
-    LanguageModelInput,
-    SimpleChatModel,
-)
-from langchain_core.language_models.chat_models import (
-    agenerate_from_stream,
-    generate_from_stream,
-)
-from langchain_core.messages import AnyMessage, BaseMessage
+from langchain_core.language_models import BaseChatModel, LanguageModelInput
+from langchain_core.messages import AIMessage, AnyMessage
 from langchain_core.runnables import Runnable, RunnableConfig, ensure_config
-from langchain_core.runnables.schema import StreamEvent
-from langchain_core.tools import BaseTool
-from langchain_core.tracers import RunLog, RunLogPatch
-from pydantic import BaseModel
-from typing_extensions import TypeAlias, override
-
-__all__ = [
-    # For backwards compatibility
-    "BaseChatModel",
-    "SimpleChatModel",
-    "agenerate_from_stream",
-    "generate_from_stream",
-    "init_chat_model",
-]
+from typing_extensions import override
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncIterator, Callable, Iterator, Sequence
+
+    from langchain_core.runnables.schema import StreamEvent
+    from langchain_core.tools import BaseTool
+    from langchain_core.tracers import RunLog, RunLogPatch
+    from pydantic import BaseModel
 
 
 @overload
 def init_chat_model(
     model: str,
     *,
-    model_provider: Optional[str] = None,
+    model_provider: str | None = None,
     configurable_fields: Literal[None] = None,
-    config_prefix: Optional[str] = None,
+    config_prefix: str | None = None,
     **kwargs: Any,
 ) -> BaseChatModel: ...
 
@@ -55,20 +41,20 @@ def init_chat_model(
 def init_chat_model(
     model: Literal[None] = None,
     *,
-    model_provider: Optional[str] = None,
+    model_provider: str | None = None,
     configurable_fields: Literal[None] = None,
-    config_prefix: Optional[str] = None,
+    config_prefix: str | None = None,
     **kwargs: Any,
 ) -> _ConfigurableModel: ...
 
 
 @overload
 def init_chat_model(
-    model: Optional[str] = None,
+    model: str | None = None,
     *,
-    model_provider: Optional[str] = None,
+    model_provider: str | None = None,
     configurable_fields: Union[Literal["any"], list[str], tuple[str, ...]] = ...,
-    config_prefix: Optional[str] = None,
+    config_prefix: str | None = None,
     **kwargs: Any,
 ) -> _ConfigurableModel: ...
 
@@ -77,69 +63,66 @@ def init_chat_model(
 # name to the supported list in the docstring below. Do *not* change the order of the
 # existing providers.
 def init_chat_model(
-    model: Optional[str] = None,
+    model: str | None = None,
     *,
-    model_provider: Optional[str] = None,
-    configurable_fields: Optional[
-        Union[Literal["any"], list[str], tuple[str, ...]]
-    ] = None,
-    config_prefix: Optional[str] = None,
+    model_provider: str | None = None,
+    configurable_fields: Union[Literal["any"], list[str], tuple[str, ...]] | None = None,
+    config_prefix: str | None = None,
     **kwargs: Any,
 ) -> Union[BaseChatModel, _ConfigurableModel]:
-    """Initialize a ChatModel in a single line using the model's name and provider.
+    """Initialize a ChatModel from the model name and provider.
 
-    .. note::
-        Must have the integration package corresponding to the model provider installed.
-        You should look at the `provider integration's API reference <https://python.langchain.com/api_reference/reference.html#integrations>`__
-        to see what parameters are supported by the model.
+    **Note:** Must have the integration package corresponding to the model provider
+    installed.
 
     Args:
-        model: The name of the model, e.g. ``'o3-mini'``, ``'claude-3-5-sonnet-latest'``. You can
+        model: The name of the model, e.g. "o3-mini", "claude-3-5-sonnet-latest". You can
             also specify model and model provider in a single argument using
-            ``'{model_provider}:{model}'`` format, e.g. ``'openai:o1'``.
+            '{model_provider}:{model}' format, e.g. "openai:o1".
         model_provider: The model provider if not specified as part of model arg (see
             above). Supported model_provider values and the corresponding integration
             package are:
 
-            - ``openai``              -> ``langchain-openai``
-            - ``anthropic``           -> ``langchain-anthropic``
-            - ``azure_openai``        -> ``langchain-openai``
-            - ``azure_ai``            -> ``langchain-azure-ai``
-            - ``google_vertexai``     -> ``langchain-google-vertexai``
-            - ``google_genai``        -> ``langchain-google-genai``
-            - ``bedrock``             -> ``langchain-aws``
-            - ``bedrock_converse``    -> ``langchain-aws``
-            - ``cohere``              -> ``langchain-cohere``
-            - ``fireworks``           -> ``langchain-fireworks``
-            - ``together``            -> ``langchain-together``
-            - ``mistralai``           -> ``langchain-mistralai``
-            - ``huggingface``         -> ``langchain-huggingface``
-            - ``groq``                -> ``langchain-groq``
-            - ``ollama``              -> ``langchain-ollama``
-            - ``google_anthropic_vertex``    -> ``langchain-google-vertexai``
-            - ``deepseek``            -> ``langchain-deepseek``
-            - ``ibm``                 -> ``langchain-ibm``
-            - ``nvidia``              -> ``langchain-nvidia-ai-endpoints``
-            - ``xai``                 -> ``langchain-xai``
-            - ``perplexity``          -> ``langchain-perplexity``
+            - 'openai'              -> langchain-openai
+            - 'anthropic'           -> langchain-anthropic
+            - 'azure_openai'        -> langchain-openai
+            - 'azure_ai'            -> langchain-azure-ai
+            - 'google_vertexai'     -> langchain-google-vertexai
+            - 'google_genai'        -> langchain-google-genai
+            - 'bedrock'             -> langchain-aws
+            - 'bedrock_converse'    -> langchain-aws
+            - 'cohere'              -> langchain-cohere
+            - 'fireworks'           -> langchain-fireworks
+            - 'together'            -> langchain-together
+            - 'mistralai'           -> langchain-mistralai
+            - 'huggingface'         -> langchain-huggingface
+            - 'groq'                -> langchain-groq
+            - 'ollama'              -> langchain-ollama
+            - 'google_anthropic_vertex'    -> langchain-google-vertexai
+            - 'deepseek'            -> langchain-deepseek
+            - 'ibm'                 -> langchain-ibm
+            - 'nvidia'              -> langchain-nvidia-ai-endpoints
+            - 'xai'                 -> langchain-xai
+            - 'perplexity'          -> langchain-perplexity
 
             Will attempt to infer model_provider from model if not specified. The
             following providers will be inferred based on these model prefixes:
 
-            - ``gpt-3...`` | ``gpt-4...`` | ``o1...`` -> ``openai``
-            - ``claude...``                       -> ``anthropic``
-            - ``amazon...``                       -> ``bedrock``
-            - ``gemini...``                       -> ``google_vertexai``
-            - ``command...``                      -> ``cohere``
-            - ``accounts/fireworks...``           -> ``fireworks``
-            - ``mistral...``                      -> ``mistralai``
-            - ``deepseek...``                     -> ``deepseek``
-            - ``grok...``                         -> ``xai``
-            - ``sonar...``                        -> ``perplexity``
-        configurable_fields: Which model parameters are configurable:
+            - 'gpt-3...' | 'gpt-4...' | 'o1...' -> 'openai'
+            - 'claude...'                       -> 'anthropic'
+            - 'amazon....'                      -> 'bedrock'
+            - 'gemini...'                       -> 'google_vertexai'
+            - 'command...'                      -> 'cohere'
+            - 'accounts/fireworks...'           -> 'fireworks'
+            - 'mistral...'                      -> 'mistralai'
+            - 'deepseek...'                     -> 'deepseek'
+            - 'grok...'                         -> 'xai'
+            - 'sonar...'                        -> 'perplexity'
+        configurable_fields: Which model parameters are
+            configurable:
 
             - None: No configurable fields.
-            - ``'any'``: All fields are configurable. **See Security Note below.**
+            - "any": All fields are configurable. *See Security Note below.*
             - Union[List[str], Tuple[str, ...]]: Specified fields are configurable.
 
             Fields are assumed to have config_prefix stripped if there is a
@@ -147,15 +130,15 @@ def init_chat_model(
             not specified, then defaults to ``("model", "model_provider")``.
 
             ***Security Note***: Setting ``configurable_fields="any"`` means fields like
-            ``api_key``, ``base_url``, etc. can be altered at runtime, potentially redirecting
+            api_key, base_url, etc. can be altered at runtime, potentially redirecting
             model requests to a different service/user. Make sure that if you're
             accepting untrusted configurations that you enumerate the
             ``configurable_fields=(...)`` explicitly.
 
-        config_prefix: If ``'config_prefix'`` is a non-empty string then model will be
+        config_prefix: If config_prefix is a non-empty string then model will be
             configurable at runtime via the
             ``config["configurable"]["{config_prefix}_{param}"]`` keys. If
-            ``'config_prefix'`` is an empty string then model will be configurable via
+            config_prefix is an empty string then model will be configurable via
             ``config["configurable"]["{param}"]``.
         temperature: Model temperature.
         max_tokens: Max output tokens.
@@ -188,7 +171,7 @@ def init_chat_model(
 
             o3_mini = init_chat_model("openai:o3-mini", temperature=0)
             claude_sonnet = init_chat_model("anthropic:claude-3-5-sonnet-latest", temperature=0)
-            gemini_2_flash = init_chat_model("google_vertexai:gemini-2.0-flash", temperature=0)
+            gemini_2_flash = init_chat_model("google_vertexai:gemini-2.5-flash", temperature=0)
 
             o3_mini.invoke("what's your name")
             claude_sonnet.invoke("what's your name")
@@ -238,7 +221,7 @@ def init_chat_model(
                 "what's your name",
                 config={
                     "configurable": {
-                        "foo_model": "anthropic:claude-3-5-sonnet-20240620",
+                        "foo_model": "anthropic:claude-3-5-sonnet-latest",
                         "foo_temperature": 0.6
                     }
                 }
@@ -280,7 +263,7 @@ def init_chat_model(
 
             configurable_model_with_tools.invoke(
                 "Which city is hotter today and which is bigger: LA or NY?",
-                config={"configurable": {"model": "claude-3-5-sonnet-20240620"}}
+                config={"configurable": {"model": "claude-3-5-sonnet-latest"}}
             )
             # Claude-3.5 sonnet response with tools
 
@@ -322,7 +305,7 @@ def init_chat_model(
 
     if not configurable_fields:
         return _init_chat_model_helper(
-            cast(str, model),
+            cast("str", model),
             model_provider=model_provider,
             **kwargs,
         )
@@ -340,7 +323,7 @@ def init_chat_model(
 def _init_chat_model_helper(
     model: str,
     *,
-    model_provider: Optional[str] = None,
+    model_provider: str | None = None,
     **kwargs: Any,
 ) -> BaseChatModel:
     model, model_provider = _parse_model(model, model_provider)
@@ -423,7 +406,6 @@ def _init_chat_model_helper(
         _check_pkg("langchain_aws")
         from langchain_aws import ChatBedrock
 
-        # TODO: update to use model= once ChatBedrock supports
         return ChatBedrock(model_id=model, **kwargs)
     if model_provider == "bedrock_converse":
         _check_pkg("langchain_aws")
@@ -461,9 +443,7 @@ def _init_chat_model_helper(
 
         return ChatPerplexity(model=model, **kwargs)
     supported = ", ".join(_SUPPORTED_PROVIDERS)
-    msg = (
-        f"Unsupported {model_provider=}.\n\nSupported model providers are: {supported}"
-    )
+    msg = f"Unsupported {model_provider=}.\n\nSupported model providers are: {supported}"
     raise ValueError(msg)
 
 
@@ -491,7 +471,7 @@ _SUPPORTED_PROVIDERS = {
 }
 
 
-def _attempt_infer_model_provider(model_name: str) -> Optional[str]:
+def _attempt_infer_model_provider(model_name: str) -> str | None:
     if any(model_name.startswith(pre) for pre in ("gpt-3", "gpt-4", "o1", "o3")):
         return "openai"
     if model_name.startswith("claude"):
@@ -515,38 +495,29 @@ def _attempt_infer_model_provider(model_name: str) -> Optional[str]:
     return None
 
 
-def _parse_model(model: str, model_provider: Optional[str]) -> tuple[str, str]:
-    if (
-        not model_provider
-        and ":" in model
-        and model.split(":")[0] in _SUPPORTED_PROVIDERS
-    ):
+def _parse_model(model: str, model_provider: str | None) -> tuple[str, str]:
+    if not model_provider and ":" in model and model.split(":")[0] in _SUPPORTED_PROVIDERS:
         model_provider = model.split(":")[0]
         model = ":".join(model.split(":")[1:])
     model_provider = model_provider or _attempt_infer_model_provider(model)
     if not model_provider:
         msg = (
-            f"Unable to infer model provider for {model=}, please specify "
-            f"model_provider directly."
+            f"Unable to infer model provider for {model=}, please specify model_provider directly."
         )
         raise ValueError(msg)
     model_provider = model_provider.replace("-", "_").lower()
     return model, model_provider
 
 
-def _check_pkg(pkg: str, *, pkg_kebab: Optional[str] = None) -> None:
+def _check_pkg(pkg: str, *, pkg_kebab: str | None = None) -> None:
     if not util.find_spec(pkg):
         pkg_kebab = pkg_kebab if pkg_kebab is not None else pkg.replace("_", "-")
-        msg = (
-            f"Unable to import {pkg}. Please install with `pip install -U {pkg_kebab}`"
-        )
+        msg = f"Unable to import {pkg}. Please install with `pip install -U {pkg_kebab}`"
         raise ImportError(msg)
 
 
 def _remove_prefix(s: str, prefix: str) -> str:
-    if s.startswith(prefix):
-        s = s[len(prefix) :]
-    return s
+    return s.removeprefix(prefix)
 
 
 _DECLARATIVE_METHODS = ("bind_tools", "with_structured_output")
@@ -556,16 +527,14 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def __init__(
         self,
         *,
-        default_config: Optional[dict] = None,
+        default_config: dict | None = None,
         configurable_fields: Union[Literal["any"], list[str], tuple[str, ...]] = "any",
         config_prefix: str = "",
         queued_declarative_operations: Sequence[tuple[str, tuple, dict]] = (),
     ) -> None:
         self._default_config: dict = default_config or {}
         self._configurable_fields: Union[Literal["any"], list[str]] = (
-            configurable_fields
-            if configurable_fields == "any"
-            else list(configurable_fields)
+            configurable_fields if configurable_fields == "any" else list(configurable_fields)
         )
         self._config_prefix = (
             config_prefix + "_"
@@ -606,14 +575,14 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         msg += "."
         raise AttributeError(msg)
 
-    def _model(self, config: Optional[RunnableConfig] = None) -> Runnable:
+    def _model(self, config: RunnableConfig | None = None) -> Runnable:
         params = {**self._default_config, **self._model_params(config)}
         model = _init_chat_model_helper(**params)
         for name, args, kwargs in self._queued_declarative_operations:
             model = getattr(model, name)(*args, **kwargs)
         return model
 
-    def _model_params(self, config: Optional[RunnableConfig]) -> dict:
+    def _model_params(self, config: RunnableConfig | None) -> dict:
         config = ensure_config(config)
         model_params = {
             _remove_prefix(k, self._config_prefix): v
@@ -621,18 +590,16 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
             if k.startswith(self._config_prefix)
         }
         if self._configurable_fields != "any":
-            model_params = {
-                k: v for k, v in model_params.items() if k in self._configurable_fields
-            }
+            model_params = {k: v for k, v in model_params.items() if k in self._configurable_fields}
         return model_params
 
     def with_config(
         self,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> _ConfigurableModel:
         """Bind config to a Runnable, returning a new Runnable."""
-        config = RunnableConfig(**(config or {}), **cast(RunnableConfig, kwargs))
+        config = RunnableConfig(**(config or {}), **cast("RunnableConfig", kwargs))
         model_params = self._model_params(config)
         remaining_config = {k: v for k, v in config.items() if k != "configurable"}
         remaining_config["configurable"] = {
@@ -679,7 +646,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def invoke(
         self,
         input: LanguageModelInput,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Any:
         return self._model(config).invoke(input, config=config, **kwargs)
@@ -688,7 +655,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     async def ainvoke(
         self,
         input: LanguageModelInput,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         **kwargs: Any,
     ) -> Any:
         return await self._model(config).ainvoke(input, config=config, **kwargs)
@@ -697,8 +664,8 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def stream(
         self,
         input: LanguageModelInput,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[Any]:
         yield from self._model(config).stream(input, config=config, **kwargs)
 
@@ -706,8 +673,8 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     async def astream(
         self,
         input: LanguageModelInput,
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[Any]:
         async for x in self._model(config).astream(input, config=config, **kwargs):
             yield x
@@ -715,10 +682,10 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def batch(
         self,
         inputs: list[LanguageModelInput],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: Union[RunnableConfig, list[RunnableConfig]] | None = None,
         *,
         return_exceptions: bool = False,
-        **kwargs: Optional[Any],
+        **kwargs: Any | None,
     ) -> list[Any]:
         config = config or None
         # If <= 1 config use the underlying models batch implementation.
@@ -743,10 +710,10 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     async def abatch(
         self,
         inputs: list[LanguageModelInput],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: Union[RunnableConfig, list[RunnableConfig]] | None = None,
         *,
         return_exceptions: bool = False,
-        **kwargs: Optional[Any],
+        **kwargs: Any | None,
     ) -> list[Any]:
         config = config or None
         # If <= 1 config use the underlying models batch implementation.
@@ -771,7 +738,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def batch_as_completed(
         self,
         inputs: Sequence[LanguageModelInput],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: Union[RunnableConfig, Sequence[RunnableConfig]] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any,
@@ -781,7 +748,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         if config is None or isinstance(config, dict) or len(config) <= 1:
             if isinstance(config, list):
                 config = config[0]
-            yield from self._model(cast(RunnableConfig, config)).batch_as_completed(  # type: ignore[call-overload]
+            yield from self._model(cast("RunnableConfig", config)).batch_as_completed(  # type: ignore[call-overload]
                 inputs,
                 config=config,
                 return_exceptions=return_exceptions,
@@ -800,7 +767,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     async def abatch_as_completed(
         self,
         inputs: Sequence[LanguageModelInput],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: Union[RunnableConfig, Sequence[RunnableConfig]] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any,
@@ -811,7 +778,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
             if isinstance(config, list):
                 config = config[0]
             async for x in self._model(
-                cast(RunnableConfig, config),
+                cast("RunnableConfig", config),
             ).abatch_as_completed(  # type: ignore[call-overload]
                 inputs,
                 config=config,
@@ -834,8 +801,8 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def transform(
         self,
         input: Iterator[LanguageModelInput],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> Iterator[Any]:
         yield from self._model(config).transform(input, config=config, **kwargs)
 
@@ -843,8 +810,8 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     async def atransform(
         self,
         input: AsyncIterator[LanguageModelInput],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Optional[Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any | None,
     ) -> AsyncIterator[Any]:
         async for x in self._model(config).atransform(input, config=config, **kwargs):
             yield x
@@ -853,16 +820,16 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def astream_log(
         self,
         input: Any,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
         diff: Literal[True] = True,
         with_streamed_output_list: bool = True,
-        include_names: Optional[Sequence[str]] = None,
-        include_types: Optional[Sequence[str]] = None,
-        include_tags: Optional[Sequence[str]] = None,
-        exclude_names: Optional[Sequence[str]] = None,
-        exclude_types: Optional[Sequence[str]] = None,
-        exclude_tags: Optional[Sequence[str]] = None,
+        include_names: Sequence[str] | None = None,
+        include_types: Sequence[str] | None = None,
+        include_tags: Sequence[str] | None = None,
+        exclude_names: Sequence[str] | None = None,
+        exclude_types: Sequence[str] | None = None,
+        exclude_tags: Sequence[str] | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[RunLogPatch]: ...
 
@@ -870,16 +837,16 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def astream_log(
         self,
         input: Any,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
         diff: Literal[False],
         with_streamed_output_list: bool = True,
-        include_names: Optional[Sequence[str]] = None,
-        include_types: Optional[Sequence[str]] = None,
-        include_tags: Optional[Sequence[str]] = None,
-        exclude_names: Optional[Sequence[str]] = None,
-        exclude_types: Optional[Sequence[str]] = None,
-        exclude_tags: Optional[Sequence[str]] = None,
+        include_names: Sequence[str] | None = None,
+        include_types: Sequence[str] | None = None,
+        include_tags: Sequence[str] | None = None,
+        exclude_names: Sequence[str] | None = None,
+        exclude_types: Sequence[str] | None = None,
+        exclude_tags: Sequence[str] | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[RunLog]: ...
 
@@ -887,16 +854,16 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     async def astream_log(
         self,
         input: Any,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
         diff: bool = True,
         with_streamed_output_list: bool = True,
-        include_names: Optional[Sequence[str]] = None,
-        include_types: Optional[Sequence[str]] = None,
-        include_tags: Optional[Sequence[str]] = None,
-        exclude_names: Optional[Sequence[str]] = None,
-        exclude_types: Optional[Sequence[str]] = None,
-        exclude_tags: Optional[Sequence[str]] = None,
+        include_names: Sequence[str] | None = None,
+        include_types: Sequence[str] | None = None,
+        include_tags: Sequence[str] | None = None,
+        exclude_names: Sequence[str] | None = None,
+        exclude_types: Sequence[str] | None = None,
+        exclude_tags: Sequence[str] | None = None,
         **kwargs: Any,
     ) -> Union[AsyncIterator[RunLogPatch], AsyncIterator[RunLog]]:
         async for x in self._model(config).astream_log(  # type: ignore[call-overload, misc]
@@ -918,15 +885,15 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     async def astream_events(
         self,
         input: Any,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
         version: Literal["v1", "v2"] = "v2",
-        include_names: Optional[Sequence[str]] = None,
-        include_types: Optional[Sequence[str]] = None,
-        include_tags: Optional[Sequence[str]] = None,
-        exclude_names: Optional[Sequence[str]] = None,
-        exclude_types: Optional[Sequence[str]] = None,
-        exclude_tags: Optional[Sequence[str]] = None,
+        include_names: Sequence[str] | None = None,
+        include_types: Sequence[str] | None = None,
+        include_tags: Sequence[str] | None = None,
+        exclude_names: Sequence[str] | None = None,
+        exclude_types: Sequence[str] | None = None,
+        exclude_tags: Sequence[str] | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[StreamEvent]:
         async for x in self._model(config).astream_events(
@@ -948,7 +915,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         self,
         tools: Sequence[Union[dict[str, Any], type[BaseModel], Callable, BaseTool]],
         **kwargs: Any,
-    ) -> Runnable[LanguageModelInput, BaseMessage]:
+    ) -> Runnable[LanguageModelInput, AIMessage]:
         return self.__getattr__("bind_tools")(tools, **kwargs)
 
     # Explicitly added to satisfy downstream linters.

langchain/{docstore/document.py → documents/__init__.py}

@@ -1,3 +1,5 @@
 from langchain_core.documents import Document
 
-__all__ = ["Document"]
+__all__ = [
+    "Document",
+]