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

langchain/chat_models/base.py

@@ -1,82 +1,61 @@
+"""Factory functions for chat models."""
+
 from __future__ import annotations
 
 import warnings
-from collections.abc import AsyncIterator, Iterator, Sequence
 from importlib import util
-from typing import Any, Callable, Literal, Optional, Union, cast, overload
-
-from langchain_core.language_models import (
-    BaseChatModel,
-    LanguageModelInput,
-    SimpleChatModel,
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    TypeAlias,
+    cast,
+    overload,
 )
-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 langchain_core.v1.chat_models import BaseChatModel as BaseChatModelV1
-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
 
-@overload
-def init_chat_model(
-    model: str,
-    *,
-    model_provider: Optional[str] = None,
-    configurable_fields: Literal[None] = None,
-    config_prefix: Optional[str] = None,
-    message_version: Literal["v0"] = "v0",
-    **kwargs: Any,
-) -> BaseChatModel: ...
+    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,
-    configurable_fields: Literal[None] = None,
-    config_prefix: Optional[str] = None,
-    message_version: Literal["v1"] = "v1",
+    model_provider: str | None = None,
+    configurable_fields: None = None,
+    config_prefix: str | None = None,
     **kwargs: Any,
-) -> BaseChatModelV1: ...
+) -> BaseChatModel: ...
 
 
 @overload
 def init_chat_model(
-    model: Literal[None] = None,
+    model: None = None,
     *,
-    model_provider: Optional[str] = None,
-    configurable_fields: Literal[None] = None,
-    config_prefix: Optional[str] = None,
-    message_version: Literal["v0", "v1"] = "v0",
+    model_provider: str | None = None,
+    configurable_fields: None = 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,
-    configurable_fields: Union[Literal["any"], list[str], tuple[str, ...]] = ...,
-    config_prefix: Optional[str] = None,
-    message_version: Literal["v0", "v1"] = "v0",
+    model_provider: str | None = None,
+    configurable_fields: Literal["any"] | list[str] | tuple[str, ...] = ...,
+    config_prefix: str | None = None,
     **kwargs: Any,
 ) -> _ConfigurableModel: ...
 
@@ -85,251 +64,216 @@ 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,
-    message_version: Literal["v0", "v1"] = "v0",
+    model_provider: str | None = None,
+    configurable_fields: Literal["any"] | list[str] | tuple[str, ...] | None = None,
+    config_prefix: str | None = None,
     **kwargs: Any,
-) -> Union[BaseChatModel, BaseChatModelV1, _ConfigurableModel]:
-    """Initialize a ChatModel in a single line using the model's 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.
-
-    Args:
-        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: 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``
-
-            Will attempt to infer model_provider from model if not specified. The
-            following providers will be inferred based on these model prefixes:
+) -> BaseChatModel | _ConfigurableModel:
+    """Initialize a chat model in a single line using the model's name and provider.
 
-            - ``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``
+    !!! note
+        Requires the integration package for your model provider to be installed.
 
-        message_version: The version of the BaseChatModel to return. Either ``"v0"`` for
-            a v0 :class:`~langchain_core.language_models.chat_models.BaseChatModel` or
-            ``"v1"`` for a v1 :class:`~langchain_core.v1.chat_models.BaseChatModel`. The
-            output version determines what type of message objects the model will
-            generate.
+        See the `model_provider` parameter below for specific package names
+        (e.g., `pip install langchain-openai`).
 
-            .. note::
-                Currently supported for these providers:
+        Refer to the [provider integration's API reference](https://docs.langchain.com/oss/python/integrations/providers)
+        for supported model parameters.
 
-                - ``openai``
-
-            .. versionadded:: 0.4.0
+    Args:
+        model: The name of the model, e.g. `'o3-mini'`, `'claude-sonnet-4-5-20250929'`.
+
+            You can also specify model and model provider in a single argument using:
+
+            `'{model_provider}:{model}'` format, e.g. `'openai:o1'`.
+        model_provider: The model provider if not specified as part of the model arg
+            (see above). Supported `model_provider` values and the corresponding
+            integration package are:
+
+            - `openai`                  -> [`langchain-openai`](https://docs.langchain.com/oss/python/integrations/providers/openai)
+            - `anthropic`               -> [`langchain-anthropic`](https://docs.langchain.com/oss/python/integrations/providers/anthropic)
+            - `azure_openai`            -> [`langchain-openai`](https://docs.langchain.com/oss/python/integrations/providers/openai)
+            - `azure_ai`                -> [`langchain-azure-ai`](https://docs.langchain.com/oss/python/integrations/providers/microsoft)
+            - `google_vertexai`         -> [`langchain-google-vertexai`](https://docs.langchain.com/oss/python/integrations/providers/google)
+            - `google_genai`            -> [`langchain-google-genai`](https://docs.langchain.com/oss/python/integrations/providers/google)
+            - `bedrock`                 -> [`langchain-aws`](https://docs.langchain.com/oss/python/integrations/providers/aws)
+            - `bedrock_converse`        -> [`langchain-aws`](https://docs.langchain.com/oss/python/integrations/providers/aws)
+            - `cohere`                  -> [`langchain-cohere`](https://docs.langchain.com/oss/python/integrations/providers/cohere)
+            - `fireworks`               -> [`langchain-fireworks`](https://docs.langchain.com/oss/python/integrations/providers/fireworks)
+            - `together`                -> [`langchain-together`](https://docs.langchain.com/oss/python/integrations/providers/together)
+            - `mistralai`               -> [`langchain-mistralai`](https://docs.langchain.com/oss/python/integrations/providers/mistralai)
+            - `huggingface`             -> [`langchain-huggingface`](https://docs.langchain.com/oss/python/integrations/providers/huggingface)
+            - `groq`                    -> [`langchain-groq`](https://docs.langchain.com/oss/python/integrations/providers/groq)
+            - `ollama`                  -> [`langchain-ollama`](https://docs.langchain.com/oss/python/integrations/providers/ollama)
+            - `google_anthropic_vertex` -> [`langchain-google-vertexai`](https://docs.langchain.com/oss/python/integrations/providers/google)
+            - `deepseek`                -> [`langchain-deepseek`](https://docs.langchain.com/oss/python/integrations/providers/deepseek)
+            - `ibm`                     -> [`langchain-ibm`](https://docs.langchain.com/oss/python/integrations/providers/deepseek)
+            - `nvidia`                  -> [`langchain-nvidia-ai-endpoints`](https://docs.langchain.com/oss/python/integrations/providers/nvidia)
+            - `xai`                     -> [`langchain-xai`](https://docs.langchain.com/oss/python/integrations/providers/xai)
+            - `perplexity`              -> [`langchain-perplexity`](https://docs.langchain.com/oss/python/integrations/providers/perplexity)
+
+            Will attempt to infer `model_provider` from model if not specified. The
+            following providers will be inferred based on these model prefixes:
 
+            - `gpt-...` | `o1...` | `o3...`       -> `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.**
-            - Union[List[str], Tuple[str, ...]]: Specified fields are configurable.
+            - `None`: No configurable fields.
+            - `'any'`: All fields are configurable. **See security note below.**
+            - `list[str] | Tuple[str, ...]`: Specified fields are configurable.
 
-            Fields are assumed to have config_prefix stripped if there is a
-            config_prefix. If model is specified, then defaults to None. If model is
-            not specified, then defaults to ``("model", "model_provider")``.
+            Fields are assumed to have `config_prefix` stripped if there is a
+            `config_prefix`. If model is specified, then defaults to `None`. If model is
+            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
-            model requests to a different service/user. Make sure that if you're
-            accepting untrusted configurations that you enumerate the
-            ``configurable_fields=(...)`` explicitly.
+            !!! warning "Security note"
+                Setting `configurable_fields="any"` means fields like `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["configurable"]["{param}"]``.
-        temperature: Model temperature.
-        max_tokens: Max output tokens.
-        timeout: The maximum time (in seconds) to wait for a response from the model
-            before canceling the request.
-        max_retries: The maximum number of attempts the system will make to resend a
-            request if it fails due to issues like network timeouts or rate limits.
-        base_url: The URL of the API endpoint where requests are sent.
-        rate_limiter: A ``BaseRateLimiter`` to space out requests to avoid exceeding
-            rate limits.
-        kwargs: Additional model-specific keyword args to pass to
-            ``<<selected ChatModel>>.__init__(model=model_name, **kwargs)``.
+            `config["configurable"]["{config_prefix}_{param}"]` keys. If
+            `'config_prefix'` is an empty string then model will be configurable via
+            `config["configurable"]["{param}"]`.
+        **kwargs: Additional model-specific keyword args to pass to the underlying
+            chat model's `__init__` method. Common parameters include:
+
+            - `temperature`: Model temperature for controlling randomness.
+            - `max_tokens`: Maximum number of output tokens.
+            - `timeout`: Maximum time (in seconds) to wait for a response.
+            - `max_retries`: Maximum number of retry attempts for failed requests.
+            - `base_url`: Custom API endpoint URL.
+            - `rate_limiter`: A `BaseRateLimiter` instance to control request rate.
+
+            Refer to the specific model provider's documentation for all available
+            parameters.
 
     Returns:
-        A BaseChatModel corresponding to the model_name and model_provider specified if
-        configurability is inferred to be False. If configurable, a chat model emulator
-        that initializes the underlying model at runtime once a config is passed in.
+        A `BaseChatModel` corresponding to the `model_name` and `model_provider`
+            specified if configurability is inferred to be `False`. If configurable, a
+            chat model emulator that initializes the underlying model at runtime once a
+            config is passed in.
 
     Raises:
-        ValueError: If model_provider cannot be inferred or isn't supported.
+        ValueError: If `model_provider` cannot be inferred or isn't supported.
         ImportError: If the model provider integration package is not installed.
 
-    .. dropdown:: Init non-configurable model
-        :open:
-
-        .. code-block:: python
-
-            # pip install langchain langchain-openai langchain-anthropic langchain-google-vertexai
-            from langchain.chat_models import init_chat_model
+    ???+ note "Initialize a non-configurable 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.5-flash", temperature=0)
+        ```python
+        # pip install langchain langchain-openai langchain-anthropic langchain-google-vertexai
+        from langchain.chat_models import init_chat_model
 
-            o3_mini.invoke("what's your name")
-            claude_sonnet.invoke("what's your name")
-            gemini_2_flash.invoke("what's your name")
+        o3_mini = init_chat_model("openai:o3-mini", temperature=0)
+        claude_sonnet = init_chat_model("anthropic:claude-sonnet-4-5-20250929", 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")
+        gemini_2_flash.invoke("what's your name")
+        ```
 
-    .. dropdown:: Partially configurable model with no default
+    ??? note "Partially configurable model with no default"
 
-        .. code-block:: python
+        ```python
+        # pip install langchain langchain-openai langchain-anthropic
+        from langchain.chat_models import init_chat_model
 
-            # pip install langchain langchain-openai langchain-anthropic
-            from langchain.chat_models import init_chat_model
+        # We don't need to specify configurable=True if a model isn't specified.
+        configurable_model = init_chat_model(temperature=0)
 
-            # We don't need to specify configurable=True if a model isn't specified.
-            configurable_model = init_chat_model(temperature=0)
+        configurable_model.invoke("what's your name", config={"configurable": {"model": "gpt-4o"}})
+        # GPT-4o response
 
-            configurable_model.invoke(
-                "what's your name",
-                config={"configurable": {"model": "gpt-4o"}}
-            )
-            # GPT-4o response
-
-            configurable_model.invoke(
-                "what's your name",
-                config={"configurable": {"model": "claude-3-5-sonnet-latest"}}
-            )
-            # claude-3.5 sonnet response
-
-    .. dropdown:: Fully configurable model with a default
+        configurable_model.invoke(
+            "what's your name",
+            config={"configurable": {"model": "claude-sonnet-4-5-20250929"}},
+        )
+        ```
 
-        .. code-block:: python
+    ??? note "Fully configurable model with a default"
 
-            # pip install langchain langchain-openai langchain-anthropic
-            from langchain.chat_models import init_chat_model
+        ```python
+        # pip install langchain langchain-openai langchain-anthropic
+        from langchain.chat_models import init_chat_model
 
-            configurable_model_with_default = init_chat_model(
-                "openai:gpt-4o",
-                configurable_fields="any",  # this allows us to configure other params like temperature, max_tokens, etc at runtime.
-                config_prefix="foo",
-                temperature=0
-            )
+        configurable_model_with_default = init_chat_model(
+            "openai:gpt-4o",
+            configurable_fields="any",  # This allows us to configure other params like temperature, max_tokens, etc at runtime.
+            config_prefix="foo",
+            temperature=0,
+        )
 
-            configurable_model_with_default.invoke("what's your name")
-            # GPT-4o response with temperature 0
+        configurable_model_with_default.invoke("what's your name")
+        # GPT-4o response with temperature 0
 
-            configurable_model_with_default.invoke(
-                "what's your name",
-                config={
-                    "configurable": {
-                        "foo_model": "anthropic:claude-3-5-sonnet-20240620",
-                        "foo_temperature": 0.6
-                    }
+        configurable_model_with_default.invoke(
+            "what's your name",
+            config={
+                "configurable": {
+                    "foo_model": "anthropic:claude-sonnet-4-5-20250929",
+                    "foo_temperature": 0.6,
                 }
-            )
-            # Claude-3.5 sonnet response with temperature 0.6
-
-    .. dropdown:: Bind tools to a configurable model
-
-        You can call any ChatModel declarative methods on a configurable model in the
-        same way that you would with a normal model.
-
-        .. code-block:: python
-
-            # pip install langchain langchain-openai langchain-anthropic
-            from langchain.chat_models import init_chat_model
-            from pydantic import BaseModel, Field
-
-            class GetWeather(BaseModel):
-                '''Get the current weather in a given location'''
-
-                location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
-
-            class GetPopulation(BaseModel):
-                '''Get the current population in a given location'''
-
-                location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
+            },
+        )
+        ```
 
-            configurable_model = init_chat_model(
-                "gpt-4o",
-                configurable_fields=("model", "model_provider"),
-                temperature=0
-            )
+    ??? note "Bind tools to a configurable model"
 
-            configurable_model_with_tools = configurable_model.bind_tools([GetWeather, GetPopulation])
-            configurable_model_with_tools.invoke(
-                "Which city is hotter today and which is bigger: LA or NY?"
-            )
-            # GPT-4o response with tool calls
+        You can call any chat model declarative methods on a configurable model in the
+        same way that you would with a normal 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"}}
-            )
-            # Claude-3.5 sonnet response with tools
+        ```python
+        # pip install langchain langchain-openai langchain-anthropic
+        from langchain.chat_models import init_chat_model
+        from pydantic import BaseModel, Field
 
-    .. versionadded:: 0.2.7
 
-    .. versionchanged:: 0.2.8
+        class GetWeather(BaseModel):
+            '''Get the current weather in a given location'''
 
-        Support for ``configurable_fields`` and ``config_prefix`` added.
+            location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
 
-    .. versionchanged:: 0.2.12
 
-        Support for Ollama via langchain-ollama package added
-        (langchain_ollama.ChatOllama). Previously,
-        the now-deprecated langchain-community version of Ollama was imported
-        (langchain_community.chat_models.ChatOllama).
+        class GetPopulation(BaseModel):
+            '''Get the current population in a given location'''
 
-        Support for AWS Bedrock models via the Converse API added
-        (model_provider="bedrock_converse").
+            location: str = Field(..., description="The city and state, e.g. San Francisco, CA")
 
-    .. versionchanged:: 0.3.5
 
-        Out of beta.
+        configurable_model = init_chat_model(
+            "gpt-4o", configurable_fields=("model", "model_provider"), temperature=0
+        )
 
-    .. versionchanged:: 0.3.19
+        configurable_model_with_tools = configurable_model.bind_tools(
+            [
+                GetWeather,
+                GetPopulation,
+            ]
+        )
+        configurable_model_with_tools.invoke(
+            "Which city is hotter today and which is bigger: LA or NY?"
+        )
 
-        Support for Deepseek, IBM, Nvidia, and xAI models added.
+        configurable_model_with_tools.invoke(
+            "Which city is hotter today and which is bigger: LA or NY?",
+            config={"configurable": {"model": "claude-sonnet-4-5-20250929"}},
+        )
+        ```
 
     """  # noqa: E501
     if not model and not configurable_fields:
@@ -347,7 +291,6 @@ def init_chat_model(
         return _init_chat_model_helper(
             cast("str", model),
             model_provider=model_provider,
-            message_version=message_version,
             **kwargs,
         )
     if model:
@@ -364,28 +307,15 @@ def init_chat_model(
 def _init_chat_model_helper(
     model: str,
     *,
-    model_provider: Optional[str] = None,
-    message_version: Literal["v0", "v1"] = "v0",
+    model_provider: str | None = None,
     **kwargs: Any,
-) -> Union[BaseChatModel, BaseChatModelV1]:
+) -> BaseChatModel:
     model, model_provider = _parse_model(model, model_provider)
-    if message_version != "v0" and model_provider not in ("openai",):
-        warnings.warn(
-            f"Model provider {model_provider} does not support "
-            f"message_version={message_version}. Defaulting to v0.",
-            stacklevel=2,
-        )
     if model_provider == "openai":
         _check_pkg("langchain_openai")
-        if message_version == "v0":
-            from langchain_openai import ChatOpenAI
-
-            return ChatOpenAI(model=model, **kwargs)
-        # v1
-        from langchain_openai.v1 import ChatOpenAI as ChatOpenAIV1
-
-        return ChatOpenAIV1(model=model, **kwargs)
+        from langchain_openai import ChatOpenAI
 
+        return ChatOpenAI(model=model, **kwargs)
     if model_provider == "anthropic":
         _check_pkg("langchain_anthropic")
         from langchain_anthropic import ChatAnthropic
@@ -460,7 +390,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")
@@ -498,9 +427,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)
 
 
@@ -528,8 +455,8 @@ _SUPPORTED_PROVIDERS = {
 }
 
 
-def _attempt_infer_model_provider(model_name: str) -> Optional[str]:
-    if any(model_name.startswith(pre) for pre in ("gpt-3", "gpt-4", "o1", "o3")):
+def _attempt_infer_model_provider(model_name: str) -> str | None:
+    if any(model_name.startswith(pre) for pre in ("gpt-", "o1", "o3")):
         return "openai"
     if model_name.startswith("claude"):
         return "anthropic"
@@ -552,38 +479,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")
@@ -593,16 +511,14 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def __init__(
         self,
         *,
-        default_config: Optional[dict] = None,
-        configurable_fields: Union[Literal["any"], list[str], tuple[str, ...]] = "any",
+        default_config: dict | None = None,
+        configurable_fields: 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)
+        self._configurable_fields: Literal["any"] | list[str] = (
+            configurable_fields if configurable_fields == "any" else list(configurable_fields)
         )
         self._config_prefix = (
             config_prefix + "_"
@@ -643,14 +559,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
@@ -658,14 +574,12 @@ 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."""
@@ -697,7 +611,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
 
     @property
     def InputType(self) -> TypeAlias:
-        """Get the input type for this runnable."""
+        """Get the input type for this `Runnable`."""
         from langchain_core.prompt_values import (
             ChatPromptValueConcrete,
             StringPromptValue,
@@ -706,17 +620,13 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         # This is a version of LanguageModelInput which replaces the abstract
         # base class BaseMessage with a union of its subclasses, which makes
         # for a much better schema.
-        return Union[
-            str,
-            Union[StringPromptValue, ChatPromptValueConcrete],
-            list[AnyMessage],
-        ]
+        return str | StringPromptValue | ChatPromptValueConcrete | list[AnyMessage]
 
     @override
     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)
@@ -725,7 +635,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)
@@ -734,8 +644,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)
 
@@ -743,8 +653,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
@@ -752,10 +662,10 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def batch(
         self,
         inputs: list[LanguageModelInput],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: 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.
@@ -780,10 +690,10 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     async def abatch(
         self,
         inputs: list[LanguageModelInput],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: 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.
@@ -808,11 +718,11 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     def batch_as_completed(
         self,
         inputs: Sequence[LanguageModelInput],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any,
-    ) -> Iterator[tuple[int, Union[Any, Exception]]]:
+    ) -> Iterator[tuple[int, Any | Exception]]:
         config = config or None
         # If <= 1 config use the underlying models batch implementation.
         if config is None or isinstance(config, dict) or len(config) <= 1:
@@ -837,7 +747,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     async def abatch_as_completed(
         self,
         inputs: Sequence[LanguageModelInput],
-        config: Optional[Union[RunnableConfig, Sequence[RunnableConfig]]] = None,
+        config: RunnableConfig | Sequence[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any,
@@ -871,8 +781,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)
 
@@ -880,8 +790,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
@@ -890,16 +800,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]: ...
 
@@ -907,16 +817,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]: ...
 
@@ -924,18 +834,18 @@ 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]]:
+    ) -> AsyncIterator[RunLogPatch] | AsyncIterator[RunLog]:
         async for x in self._model(config).astream_log(  # type: ignore[call-overload, misc]
             input,
             config=config,
@@ -955,15 +865,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(
@@ -983,15 +893,15 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     # Explicitly added to satisfy downstream linters.
     def bind_tools(
         self,
-        tools: Sequence[Union[dict[str, Any], type[BaseModel], Callable, BaseTool]],
+        tools: Sequence[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.
     def with_structured_output(
         self,
-        schema: Union[dict, type[BaseModel]],
+        schema: dict | type[BaseModel],
         **kwargs: Any,
-    ) -> Runnable[LanguageModelInput, Union[dict, BaseModel]]:
+    ) -> Runnable[LanguageModelInput, dict | BaseModel]:
         return self.__getattr__("with_structured_output")(schema, **kwargs)